C++ 智能指针std::unique_ptr独占所有权实现

理解 智能指针是C++管理内存的重要工具，而std::unique_ptr提供了独占所有权语义，确保资源安全释放。

1. 认识std::unique_ptr

std::unique_ptr是C++11引入的智能指针，它实现了独占所有权模式。掌握 this指针类型的关键在于理解它只能指向一个对象，且在该对象生命周期结束时自动释放内存。

创建 std::unique_ptr最简单的方式：

#include <memory>

// 原始指针创建
std::unique_ptr<int> ptr1(new int(42));

// make_unique函数(C++14推荐)
auto ptr2 = std::make_unique<int>(42);

避免 原始指针直接转换到std::unique_ptr，而是使用std::make_unique函数，它更安全且性能更优。

2. std::unique_ptr的基本操作

创建 std::unique_ptr后，可以执行以下操作：

// 获取所指向的值
int value = *ptr1;
std::cout << *ptr1 << std::endl;

// 获取原始指针
int* rawPtr = ptr1.get();

// 检查指针是否有效
if (ptr1) {
    // 执行操作
}

// 释放所有权并获取原始指针
int* releasedPtr = ptr1.release();
delete releasedPtr; // 现在需要手动管理

// 重置指针
ptr1.reset(new int(100));

注意 std::unique_ptr不支持拷贝构造和赋值操作，只能通过移动语义转移所有权。

3. 独占所有权的实现机制

std::unique_ptr的核心特征是独占所有权，这意味着同一时间只有一个指针可以拥有资源：

尝试 复制std::unique_ptr会导致编译错误：

std::unique_ptr<int> p1(new int(42));
std::unique_ptr<int> p2 = p1; // 编译错误！无法复制

使用 移动语义转移所有权：

std::unique_ptr<int> p1(new int(42));
std::unique_ptr<int> p2 = std::move(p1); // 所有权转移，p1变为空

// 此时p1为空，p2拥有唯一的所有权

4. 自定义删除器

创建 std::unique_ptr时，可以指定自定义删除器：

// 使用函数指针作为删除器
void customDelete(int* p) {
    std::cout << "自定义删除器被调用" << std::endl;
    delete p;
}

std::unique_ptr<int, decltype(&customDelete)> ptr(new int(42), customDelete);

// 使用lambda表达式作为删除器
auto lambdaDeleter = [](int* p) {
    std::cout << "Lambda删除器被调用" << std::endl;
    delete p;
};

std::unique_ptr<int, decltype(lambdaDeleter)> ptr2(new int(42), lambdaDeleter);

理解 自定义删除器可以处理更复杂的资源释放逻辑，如关闭文件、释放网络连接等。

5. std::unique_ptr与数组

使用 std::unique_ptr管理数组：

// C++11方式
std::unique_ptr<int[]> arr(new int[10]);
arr[0] = 42;

// C++14方式
auto arr2 = std::make_unique<int[]>(10);
arr2[0] = 42;

注意 数组版本的std::unique_ptr使用方括号[]语法，删除时使用delete[]而非delete。

6. 在容器中使用std::unique_ptr

存储 std::unique_ptr在容器中：

std::vector<std::unique_ptr<int>> vec;

// 添加元素
vec.push_back(std::make_unique<int>(42));
vec.emplace_back(std::make_unique<int>(100));

// 所有权转移
auto ptr = std::move(vec[0]);
vec.erase(vec.begin());

注意 容器中存储std::unique_ptr时，必须使用移动语义而非拷贝。

7. std::unique_ptr与其他智能指针比较

比较 std::unique_ptr与其他智能指针：

选择 智能指针类型时，考虑以下几点：

• 如果对象只需要一个所有者，使用std::unique_ptr
• 如果需要共享所有权，使用std::shared_ptr
• 仅需要观察shared_ptr管理的对象，使用std::weak_ptr

8. 实际应用案例

实现 资源管理模式：

class Resource {
public:
    Resource(int id) : id_(id) {
        std::cout << "资源 " << id_ << " 已创建" << std::endl;
    }
    ~Resource() {
        std::cout << "资源 " << id_ << " 已销毁" << std::endl;
    }
    void use() {
        std::cout << "使用资源 " << id_ << std::endl;
    }
private:
    int id_;
};

int main() {
    // 使用unique_ptr管理资源
    auto res = std::make_unique<Resource>(1);
    res->use();

    { // 限定作用域
        auto innerRes = std::make_unique<Resource>(2);
        innerRes->use();
    } // innerRes在此处自动销毁

    // res仍然可用
    res->use();

    return 0;
}

输出：

资源 1 已创建
使用资源 1
资源 2 已创建
使用资源 2
资源 2 已销毁
使用资源 1
资源 1 已销毁

理解 std::unique_ptr确保资源在离开作用域时自动释放，无需手动delete，避免内存泄漏。

9. std::unique_ptr的最佳实践

应用 以下最佳实践提高代码质量：

1. 优先使用 std::make_unique而非new创建对象

   auto ptr = std::make_unique MyClass>(arg1, arg2);
   // 而非 std::unique_ptr<MyClass> ptr(new MyClass(arg1, arg2));

2. 避免 将std::unique_ptr转换为原始指针，除非必要

   // 不推荐
   MyClass* rawPtr = ptr.get();
   rawPtr->someMethod();
   
   // 推荐
   ptr->someMethod();

3. 使用 移动语义转移所有权

   void process(std::unique_ptr<Resource> res) {
       res->use();
   }
   
   auto res = std::make_unique<Resource>(1);
   process(std::move(res)); // 移动所有权

4. 避免 在STL容器中混合使用原始指针和std::unique_ptr

   // 不推荐
   std::vector<std::unique_ptr<Resource>> vec;
   vec.push_back(new Resource(1)); // 错误
   
   // 推荐
   vec.push_back(std::make_unique<Resource>(1));

5. 谨慎使用 std::unique_ptr的原始指针获取(get())和释放(release())方法，确保不会造成资源泄漏

识别 当代码中需要管理动态分配的内存或资源时，std::unique_ptr是理想的选择，它能提供自动资源管理同时保持高性能。

采用 std::unique_ptr可以显著减少内存泄漏的风险，使代码更加安全和可维护，特别是在异常处理场景中。