C++智能指针unique_ptr

一、unique_ptr 是什么？

unique_ptr 是 C++ 标准库（<memory> 头文件）提供的一种智能指针，它的核心特点是独占所有权。简单来说，一个 unique_ptr 对象 管理一块动态分配的内存（通常通过 new 创建），并且保证这份内存只属于它一个人。当 unique_ptr 被销毁（比如超出作用域）时，它会自动释放所管理的内存，无需手动调用 delete。

与另一个智能指针 shared_ptr（共享所有权）不同，unique_ptr 不允许拷贝，只能通过移动（std::move）转移所有权。这种设计确保了资源的唯一性，避免了多个指针同时管理同一块内存带来的混乱。

基本用法示例

#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int> ptr = std::make_unique<int>(42); // 创建并管理一个 int
    std::cout << *ptr << std::endl; // 输出 42
    // ptr 超出作用域时，内存自动释放
    return 0;
}

在这个例子中，ptr 管理一个值为 42 的整数，当程序结束时，ptr 自动释放内存，避免了内存泄漏。

注意： std::make_unique是C++14的特性。

二、unique_ptr 的核心特性

1. 独占所有权与不可拷贝

unique_ptr 的“独占”体现在它不能被拷贝，只能被移动。如果尝试拷贝，会导致编译错误：

std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
// std::unique_ptr<int> ptr2 = ptr1; // 错误！不能拷贝

但可以通过 std::move 转移所有权：

std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
std::unique_ptr<int> ptr2 = std::move(ptr1); // 所有权转移给 ptr2
// 现在 ptr1 为空，ptr2 管理 10

转移后，ptr1 变成空指针（nullptr），而 ptr2 接管了资源。

注意：转移之前，如果ptr2不为空，会先释放，再转移。

2. 核心操作

unique_ptr 提供了几个关键方法，用于灵活管理资源：

• release()：放弃所有权，返回裸指针，但不释放被管理对象的内存。

  auto ptr = std::make_unique<int>(20);
  int* raw = ptr.release(); // ptr 变为空，raw 指向 20
  delete raw; // 需要手动释放
  

• reset()：释放当前管理的资源，并可选地接管新资源。

  auto ptr = std::make_unique<int>(30);
  ptr.reset(new int(40)); // 释放 30，接管 40
  

• swap()：交换两个 unique_ptr 的内容。

  auto ptr1 = std::make_unique<int>(50);
  auto ptr2 = std::make_unique<int>(60);
  ptr1.swap(ptr2); // ptr1 管理 60，ptr2 管理 50
  

这些操作让 unique_ptr 在资源管理中更加灵活，但也需要小心使用（后面会提到陷阱）。

三、unique_ptr 的典型应用场景

1. 工厂模式：清晰的所有权语义

工厂模式是一种常见的设计模式，用于创建对象并隐藏创建细节。使用 unique_ptr 可以让工厂方法返回一个独占的对象，明确表示调用者是资源的唯一所有者。

示例代码

#include <memory>
#include <iostream>

class Product {
public:
    virtual void use() = 0;
    virtual ~Product() = default;
};

class ConcreteProduct : public Product {
public:
    void use() override { std::cout << "Using product" << std::endl; }
};

std::unique_ptr<Product> factory() {
    return std::make_unique<ConcreteProduct>();
}

int main() {
    auto product = factory();
    product->use(); // 输出 "Using product"
    return 0;
}

• 优点：
  • 调用者无需手动释放内存。
  • unique_ptr 表明资源独占，避免了意外共享的风险。
• 与 shared_ptr 的对比：如果需要多个地方共享对象，可以用 shared_ptr，但 unique_ptr 更轻量且语义更明确。

2. 与容器结合：管理动态对象集合

unique_ptr 可以放入容器（如 std::vector），但由于不可拷贝，必须使用 std::move 转移所有权。

示例代码

#include <memory>
#include <vector>
#include <iostream>

int main() {
    std::unique_ptr<int> ptr = std::make_unique<int>(100);
    std::vector<std::unique_ptr<int>> vec;
    vec.push_back(std::move(ptr)); // 转移所有权
    std::cout << *vec[0] << std::endl; // 输出 100
    return 0;
}

• 注意：如果直接 push_back(ptr)，会因拷贝被禁用而报错。

3. 管理动态数组：自动释放

unique_ptr 支持管理动态数组，通过 unique_ptr<T[]> 特化版本，析构时会自动调用 delete[]。

示例代码

#include <memory>
#include <iostream>

int main() {
    auto arr = std::make_unique<int[]>(3); // 分配 3 个 int 的数组
    arr[0] = 1;
    arr[1] = 2;
    arr[2] = 3;
    for (int i = 0; i < 3; ++i) {
        std::cout << arr[i] << " "; // 输出 "1 2 3"
    }
    return 0;
}

• 释放机制：unique_ptr<T[]> 确保调用 delete[]，正确释放整个数组，避免内存问题。

四、unique_ptr 与 scoped_ptr 的对比

scoped_ptr 是 Boost 库提供的一种智能指针，与 unique_ptr 类似，但更严格：

• scoped_ptr：不可拷贝、不可移动，完全独占，适合局部作用域或类成员。
• unique_ptr：支持移动，可以转移所有权，应用更灵活。
• 选择：如果不需要转移所有权，scoped_ptr 语义更纯粹；否则，unique_ptr 是更好的选择。

五、需要注意的陷阱

1. release() 的风险

调用 release() 后，unique_ptr 放弃所有权，返回裸指针。如果忘记手动释放这个裸指针，会导致内存泄漏。

auto ptr = std::make_unique<int>(200);
int* raw = ptr.release();
// 忘记 delete raw，会泄漏内存

• 建议：尽量少用 release()，除非明确需要将资源移交。

2. 避免同一裸指针多次管理

如果将同一个裸指针交给多个 unique_ptr，会导致双重释放：

int* raw = new int(300);
std::unique_ptr<int> ptr1(raw);
std::unique_ptr<int> ptr2(raw); // 错误！双重 delete

3. get() 与 release() 的区别

• get()：返回裸指针，但不放弃所有权，unique_ptr 仍负责释放。
• release()：返回裸指针并放弃所有权，需要手动管理。

六、总结

unique_ptr 是现代 C++ 中管理动态内存的利器，它通过独占所有权和自动释放机制，简化了资源管理，同时保持高效和安全。无论是实现工厂模式、管理容器中的对象，还是处理动态数组，unique_ptr 都能胜任。掌握它的核心操作（如 release、reset、swap）和注意事项（如 std::move 的使用），能让您在编写代码时更加得心应手。