C++如何使用unique_ptr管理动态对象

P粉602998670

发布时间：2025-09-17 13:56:01

327人浏览过

来源于php中文网

原创

unique_ptr通过独占所有权和RAII机制自动管理内存，避免内存泄漏；它不可复制，只能通过std::move转移所有权，适用于单一所有者场景，性能优于shared_ptr，是现代C++资源管理的首选方案。

c++如何使用unique_ptr管理动态对象

unique_ptr

在 C++ 中提供了一种独占所有权的智能指针机制，它能自动管理动态分配的对象，确保在指针超出作用域时，关联的内存资源会被安全、及时地释放，从而有效避免内存泄漏和悬空指针等问题。简单来说，它让动态内存的管理变得更省心，更安全。

解决方案

unique_ptr

的核心思想是“独占所有权”。这意味着在任何给定时间，只有一个

unique_ptr

实例能够拥有并管理特定的动态对象。当这个

unique_ptr

被销毁时（例如，超出其作用域），它所指向的对象也会被自动删除。这极大地简化了资源管理，遵循了 C++ 的 RAII（Resource Acquisition Is Initialization）原则。

要使用

unique_ptr

，最推荐的方式是利用

std::make_unique

工厂函数来创建。这不仅语法更简洁，而且在异常安全方面也优于直接使用

new

。

#include 
#include  // 包含 unique_ptr 的头文件
#include 

class MyObject {
public:
    int id;
    MyObject(int i) : id(i) {
        std::cout << "MyObject " << id << " created." << std::endl;
    }
    ~MyObject() {
        std::cout << "MyObject " << id << " destroyed." << std::endl;
    }
    void doSomething() {
        std::cout << "MyObject " << id << " is doing something." << std::endl;
    }
};

// 函数返回 unique_ptr，所有权被转移
std::unique_ptr createObject(int id) {
    std::cout << "Inside createObject." << std::endl;
    return std::make_unique(id); // 返回时所有权会转移
}

void processObject(std::unique_ptr obj) { // 接收 unique_ptr，所有权转移到函数内部
    std::cout << "Inside processObject." << std::endl;
    if (obj) {
        obj->doSomething();
    }
    // obj 在这里超出作用域，MyObject 会被销毁
    std::cout << "Exiting processObject." << std::endl;
}

int main() {
    // 1. 使用 std::make_unique 创建 unique_ptr
    std::unique_ptr ptr1 = std::make_unique(1);
    ptr1->doSomething(); // 访问对象成员

    // 2. unique_ptr 不可复制，只能通过 std::move 转移所有权
    // std::unique_ptr ptr2 = ptr1; // 编译错误！
    std::unique_ptr ptr2 = std::move(ptr1); // 所有权从 ptr1 转移到 ptr2
    if (ptr1) { // ptr1 现在是空的
        std::cout << "ptr1 still holds an object." << std::endl;
    } else {
        std::cout << "ptr1 is now empty." << std::endl;
    }
    ptr2->doSomething(); // ptr2 现在拥有对象

    // 3. 作为函数返回值
    std::unique_ptr ptr3 = createObject(3);
    ptr3->doSomething();

    // 4. 作为函数参数（传递所有权）
    processObject(std::move(ptr3)); // ptr3 的所有权转移到 processObject 内部
    if (!ptr3) {
        std::cout << "ptr3 is now empty after moving to processObject." << std::endl;
    }

    // 5. unique_ptr 管理数组
    std::unique_ptr objArray = std::make_unique(2);
    objArray[0].id = 4;
    objArray[1].id = 5;
    objArray[0].doSomething();
    objArray[1].doSomething();
    // 当 objArray 超出作用域时，MyObject[4] 和 MyObject[5] 都会被销毁

    // 6. 自定义删除器：当需要用非 delete 方式释放资源时
    // 比如文件句柄，需要 fclose
    auto file_closer = [](FILE* f) {
        if (f) {
            std::cout << "Closing file..." << std::endl;
            fclose(f);
        }
    };
    std::unique_ptr file_ptr(fopen("test.txt", "w"), file_closer);
    if (file_ptr) {
        fputs("Hello unique_ptr!\n", file_ptr.get());
        std::cout << "File opened and written to." << std::endl;
    } else {
        std::cerr << "Failed to open file!" << std::endl;
    }
    // file_ptr 超出作用域时，file_closer 会被调用来关闭文件

    std::cout << "End of main function." << std::endl;
    return 0;
}

通过上面的例子，我们可以看到

unique_ptr

就像一个忠实的管家，它会确保你分配的内存最终能被妥善处理。一旦你把一个动态对象“委托”给它，就不用再操心

delete

的事情了。

立即学习“C++免费学习笔记（深入）”；

为什么需要unique_ptr？它解决了哪些传统C++内存管理痛点？

回想一下 C++ 早期，我们处理动态内存主要靠

new

和

delete

。这套机制在小规模、简单的程序里还勉强能用，但一旦项目规模扩大，或者代码逻辑变得复杂，比如涉及异常处理、多分支返回路径、循环等，内存泄漏就成了家常便饭。忘记

delete

、在错误的地方

delete

、重复

delete

同一块内存，这些都是让人头疼的常见错误。我记得有一次，在一个复杂的函数里，因为一个

if

语句的某个分支没有

delete

掉之前

new

出来的对象，导致了一个很难追踪的内存泄漏，那真的是调试到头秃。

unique_ptr

完美地解决了这些痛点。它基于 RAII（Resource Acquisition Is Initialization）原则，这是一种非常 C++ 的思想：资源在构造时获取，在析构时释放。

unique_ptr

在其构造时获取动态内存的所有权，并在其生命周期结束时（即析构时）自动调用

delete

释放内存。这意味着你不再需要手动管理

delete

，大大降低了出错的可能性。

它还解决了异常安全问题。想象一下，如果在

new

之后、

delete

之前发生了异常，那么

delete

语句可能永远不会被执行，导致内存泄漏。而

unique_ptr

作为栈上的对象，无论函数如何退出（正常返回或抛出异常），它的析构函数都会被调用，从而保证内存得到释放。

相比于 C++98/03 的

auto_ptr

，

unique_ptr

更加安全和明确。

auto_ptr

的一个大坑是它的复制行为会导致所有权转移，这常常让人感到困惑，甚至引入难以发现的 bug。

unique_ptr

则直接禁止了复制，只允许通过

std::move

显式地转移所有权，这让代码的意图变得一目了然，避免了隐式行为带来的风险。可以说，

unique_ptr

是现代 C++ 中管理独占资源的首选工具，它让代码更健壮，也更容易理解。

unique_ptr与shared_ptr、weak_ptr有何不同？何时选择unique_ptr？

当我们谈论 C++ 智能指针，除了

unique_ptr

，

shared_ptr

和

weak_ptr

也是绕不开的话题。它们三者各自扮演着不同的角色，理解它们的区别是正确选择和使用的关键。

最核心的区别在于它们对资源的所有权模型：

```
unique_ptr
```
：独占所有权。 就像它的名字一样，一个
```
unique_ptr
```
实例独占它所指向的资源。不允许复制，只能通过
```
std::move
```
转移所有权。当
```
unique_ptr
```
被销毁时，它所拥有的资源也会被释放。它不涉及引用计数，因此开销最小。
```
shared_ptr
```
：共享所有权。 多个
```
shared_ptr
```
实例可以共同拥有同一个资源。它通过内部的引用计数机制来跟踪有多少个
```
shared_ptr
```
正在指向该资源。只有当最后一个
```
shared_ptr
```
被销毁时，资源才会被释放。这种共享所有权模型带来了更大的灵活性，但也伴随着额外的开销（维护引用计数）以及潜在的循环引用问题。
```
weak_ptr
```
：非所有权引用。
```
weak_ptr
```
不拥有资源，它只是对
```
shared_ptr
```
所管理资源的一个“弱引用”。它不会增加资源的引用计数，因此不会阻止资源被释放。
```
weak_ptr
```
主要用于解决
```
shared_ptr
```
带来的循环引用问题，或者在不希望延长对象生命周期的情况下安全地访问对象。你需要先将其提升为
```
shared_ptr
```
（通过
```
lock()
```
方法）才能访问其指向的对象，如果对象已被释放，
```
lock()
```
会返回一个空的
```
shared_ptr
```
。

中网互连企业网站管理系统201106
中网互连企业网站管理系统是专门针对企业而开发的一套功能强大的网站管理系统，使用成熟的ASP技术开发的动态网站系统。简单易用、功能强大，能让懂上网的人就能自助管理管理网站。三年的开发和几千用户使用验证，是一套可靠实用，稳定安全的企业网站，适合中小企业公司建站使用。中网互连企业网站管理系统功能模块有：单页（如企业简介，联系内容等单页图文）、文章（新闻）列表、产品（图片、订单、规格说明等）、图片、下

下载

那么，何时选择

unique_ptr

呢？我的经验是，优先考虑
unique_ptr
。只有当明确需要共享所有权时，才退而求其次选择

shared_ptr

。具体来说：

明确只有一个所有者： 当你确定一个动态对象只会被一个实体拥有和管理时，
```
unique_ptr
```
是最自然、最高效的选择。例如，一个类成员，它独占一个内部资源；或者一个函数返回一个新创建的对象，并将其所有权转移给调用者。
性能敏感场景：
```
unique_ptr
```
不需要维护引用计数，它的内存开销和运行时开销都比
```
shared_ptr
```
小得多。在性能至关重要的代码路径中，或者需要管理大量小对象时，
```
unique_ptr
```
的优势就体现出来了。
作为函数返回值： 当一个函数创建了一个动态对象并希望将其所有权移交给调用者时，返回
```
unique_ptr
```
是非常安全和高效的方式。编译器通常会进行 RVO（Return Value Optimization）或 NRVO（Named Return Value Optimization），避免不必要的
```
std::move
```
。
管理数组：
```
unique_ptr
```
是管理动态分配数组的理想选择，它能确保使用正确的
```
delete[]
```
操作符来释放内存。

简单来说，如果你不需要共享对象，也不需要处理复杂的生命周期依赖，

unique_ptr

总是你的第一选择。它既安全又高效，符合“能用简单就不用复杂”的原则。

使用unique_ptr时常见的误区和最佳实践有哪些？

尽管

unique_ptr

极大简化了 C++ 的内存管理，但它也不是万能药，使用不当依然可能踩坑。我见过不少开发者，包括我自己，在使用初期都犯过一些小错误。

常见误区：

试图直接复制
unique_ptr
：这是最常见的误区。
```
unique_ptr
```
的核心是独占所有权，所以它禁止复制。
```
std::unique_ptr ptr1 = std::make_unique(1);
// std::unique_ptr ptr2 = ptr1; // 编译错误！
```
如果你确实需要转移所有权，必须使用
```
std::move
```
。
对数组使用
unique_ptr
：如果你分配了一个对象数组，比如
```
new MyObject[10]
```
，那么必须使用
```
std::unique_ptr
```
来管理它。如果错误地使用了
```
std::unique_ptr
```
，那么在销毁时只会调用
```
delete obj_ptr;
```
而不是
```
delete[] obj_ptr;
```
，这会导致未定义行为，通常是内存泄漏或崩溃。
过度依赖
get()
返回的裸指针：
```
get()
```
方法可以获取
```
unique_ptr
```
内部的裸指针。这在与 C 风格 API 交互时很有用，但如果你将这个裸指针存储起来，而
```
unique_ptr
```
却被销毁了，那么这个裸指针就成了悬空指针。之后再使用它，程序就会崩溃。
```
std::unique_ptr ptr = std::make_unique(1);
MyObject* rawPtr = ptr.get();
// ptr 在这里被销毁了，rawPtr 变成悬空指针
// ...
// rawPtr->doSomething(); // 危险！
```
在
new
和
std::make_unique
之间犹豫不决：很多人习惯了
```
new
```
，觉得
```
std::make_unique
```
只是语法糖。但实际上，
```
std::make_unique
```
在异常安全方面有显著优势。当你在一个函数调用中同时
```
new
```
一个对象并调用另一个可能抛出异常的函数时，如果没有
```
std::make_unique
```
，资源可能无法被及时清理。

最佳实践：

总是优先使用
```
std::make_unique
```
：这是创建
```
unique_ptr
```
的黄金法则。它不仅更简洁，而且能提供异常安全保证。
利用
```
std::move
```
进行所有权转移： 明确地使用
```
std::move
```
来表达所有权转移的意图，这让代码的语义非常清晰。无论是作为函数参数传递所有权，还是从一个
```
unique_ptr
```
转移到另一个，
```
std::move
```
都是你的朋友。
避免
```
get()
```
返回的裸指针泄露或悬空： 尽量只在需要与不接受智能指针的旧 API 交互时才使用
```
get()
```
。一旦将裸指针传出去，就要清楚其生命周期可能不再受
```
unique_ptr
```
控制。如果只是为了观察对象，传递对象的引用（
```
MyObject&
```
）通常是更安全的选择。
善用自定义删除器处理特殊资源：
```
unique_ptr
```
不仅仅能管理
```
new/delete
```
的内存，通过自定义删除器，它还能管理文件句柄、网络连接、互斥锁等任何需要明确释放的资源。这使得
```
unique_ptr
```
成为一个通用的 RAII 容器。
```
// 示例见解决方案部分的文件关闭器
```
作为函数参数时，考虑传递引用或裸指针： 如果函数只是需要访问
```
unique_ptr
```
所指向的对象，而不改变其所有权，那么传递
```
MyObject&
```
或
```
MyObject*
```
是更合适的。只有当函数需要接管对象的所有权时，才传递
```
std::unique_ptr
```
。
```
void observeObject(const MyObject& obj) { /* ... */ }
void takeOwnership(std::unique_ptr obj) { /* ... */ }

// main
std::unique_ptr ptr = std::make_unique(1);
observeObject(*ptr); // 传递引用
takeOwnership(std::move(ptr)); // 转移所有权
```
通过遵循这些实践，你可以充分发挥
```
unique_ptr
```
的优势，让你的 C++ 代码更加健壮、安全和易于维护。它确实是现代 C++ 编程中不可或缺的工具。