怎样在C++中使用unique_ptr？

unique_ptr是C++11引入的智能指针，属于独占所有权的智能指针类型，同一时间只能有一个unique_ptr指向某个对象，当unique_ptr被销毁时，它所指向的对象也会被自动释放，不需要手动调用delete操作。

unique_ptr的基本创建方式

创建unique_ptr最常见的方式是使用std::make_unique函数，该函数是C++14引入的，能更安全地创建unique_ptr实例，避免手动使用new带来的潜在问题。如果是C++11环境，也可以直接通过构造函数传入new出来的指针，但不推荐这种方式。

下面是两种创建方式的示例代码：

#include <memory>
#include <iostream>

int main() {
    // C++14及以上推荐方式
    std::unique_ptr<int> ptr1 = std::make_unique<int>(10);
    // C++11兼容方式，不推荐
    std::unique_ptr<int> ptr2(new int(20));
    std::cout << *ptr1 << std::endl; // 输出10
    std::cout << *ptr2 << std::endl; // 输出20
    return 0;
}

unique_ptr的常用操作

unique_ptr支持像普通指针一样的解引用操作，也提供了一些成员函数来操作管理的资源：

• operator*和operator->：用于访问指向的对象，和普通指针用法一致
• get()：返回底层管理的原始指针，注意不要手动delete这个指针
• release()：释放所有权，返回原始指针，并且将unique_ptr置为空
• reset()：释放当前管理的对象，如果需要可以传入新的指针接管新的资源
• swap()：交换两个unique_ptr管理的资源

以下是这些操作的示例代码：

#include <memory>
#include <iostream>

struct Test {
    int value;
    Test(int v) : value(v) {}
    void print() { std::cout << "value: " << value << std::endl; }
};

int main() {
    std::unique_ptr<Test> ptr = std::make_unique<Test>(5);
    // 使用operator->访问成员函数
    ptr->print(); // 输出value: 5
    // 使用operator*解引用
    std::cout << (*ptr).value << std::endl; // 输出5
    // 获取原始指针
    Test* raw_ptr = ptr.get();
    raw_ptr->print(); // 输出value: 5
    // 释放所有权
    Test* released_ptr = ptr.release();
    // 此时ptr已经为空，不能再解引用
    if (!ptr) {
        std::cout << "ptr is null" << std::endl;
    }
    delete released_ptr; // 需要手动释放release返回的指针
    // 重置unique_ptr
    ptr.reset(new Test(10));
    ptr->print(); // 输出value: 10
    return 0;
}

unique_ptr的所有权转移

unique_ptr不支持拷贝构造和拷贝赋值，因为它的所有权是独占的，但是支持移动构造和移动赋值，通过移动语义可以转移所有权。转移后原来的unique_ptr会变成空指针，不再拥有资源的所有权。

可以使用std::move来触发unique_ptr的移动操作，示例代码如下：

#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int> ptr1 = std::make_unique<int>(100);
    // 移动构造，转移所有权
    std::unique_ptr<int> ptr2 = std::move(ptr1);
    if (!ptr1) {
        std::cout << "ptr1 is null after move" << std::endl;
    }
    std::cout << *ptr2 << std::endl; // 输出100
    // 移动赋值，再次转移所有权
    std::unique_ptr<int> ptr3;
    ptr3 = std::move(ptr2);
    if (!ptr2) {
        std::cout << "ptr2 is null after move" << std::endl;
    }
    std::cout << *ptr3 << std::endl; // 输出100
    return 0;
}

unique_ptr作为函数参数和返回值

unique_ptr可以作为函数参数传递，也可以作为函数返回值，这两种场景都依赖移动语义实现所有权的转移。

如果函数需要接管unique_ptr的所有权，可以传递右值引用，或者直接使用值传递（会触发移动构造）；如果函数只是临时使用资源不需要所有权，可以传递原始指针或者普通引用。作为返回值时，编译器通常会自动进行返回值优化，不需要显式使用std::move。

示例代码如下：

#include <memory>
#include <iostream>

// 接收unique_ptr作为值参数，接管所有权
void take_ownership(std::unique_ptr<int> ptr) {
    std::cout << "take value: " << *ptr << std::endl;
}

// 返回unique_ptr，转移所有权给调用者
std::unique_ptr<int> create_ptr() {
    return std::make_unique<int>(200);
}

int main() {
    std::unique_ptr<int> ptr = std::make_unique<int>(150);
    // 传递unique_ptr给函数，需要move转移所有权
    take_ownership(std::move(ptr));
    // 此时ptr已经为空
    if (!ptr) {
        std::cout << "ptr is null after pass to function" << std::endl;
    }
    // 接收函数返回的unique_ptr
    std::unique_ptr<int> new_ptr = create_ptr();
    std::cout << *new_ptr << std::endl; // 输出200
    return 0;
}

unique_ptr的适用场景

unique_ptr适合管理那些需要独占所有权的动态资源，比如：

• 函数内部动态创建的对象，并且不需要返回给调用者
• 类的成员变量，该成员资源只属于当前类实例
• 需要管理数组类型的动态资源，unique_ptr支持数组特化版本，会自动调用delete[]释放

管理数组的示例代码如下：

#include <memory>
#include <iostream>

int main() {
    // 管理int数组
    std::unique_ptr<int[]> arr_ptr = std::make_unique<int[]>(5);
    for (int i = 0; i < 5; ++i) {
        arr_ptr[i] = i * 10;
    }
    for (int i = 0; i < 5; ++i) {
        std::cout << arr_ptr[i] << " "; // 输出0 10 20 30 40
    }
    std::cout << std::endl;
    return 0;
}

注意事项

使用unique_ptr时需要注意以下几点：

• 不要将同一个原始指针交给多个unique_ptr管理，会导致重复释放的问题
• 不要手动delete unique_ptr的get()方法返回的原始指针
• 优先使用std::make_unique创建unique_ptr，比直接new更安全，能避免异常导致的内存泄漏
• unique_ptr不能用于需要共享所有权的场景，这种场景应该使用std::shared_ptr

unique_ptrRAII移动语义智能指针修改时间：2026-07-11 21:42:44