C++如何使用unique_ptr管理动态对象-C++-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 <iostream>
#include <memory> // 包含 unique_ptr 的头文件
#include <vector>

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<MyObject> createObject(int id) {
    std::cout << "Inside createObject." << std::endl;
    return std::make_unique<MyObject>(id); // 返回时所有权会转移
}

void processObject(std::unique_ptr<MyObject> 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<MyObject> ptr1 = std::make_unique<MyObject>(1);
    ptr1->doSomething(); // 访问对象成员

    // 2. unique_ptr 不可复制，只能通过 std::move 转移所有权
    // std::unique_ptr<MyObject> ptr2 = ptr1; // 编译错误！
    std::unique_ptr<MyObject> 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<MyObject> 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<MyObject[]> objArray = std::make_unique<MyObject[]>(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, decltype(file_closer)> 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
```
登录后复制
。

如此AI写作
AI驱动的内容营销平台，提供一站式的AI智能写作、管理和分发数字化工具。

137

查看详情

那么，何时选择

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<T[]>
```
登录后复制
是管理动态分配数组的理想选择，它能确保使用正确的
```
delete[]
```
登录后复制
操作符来释放内存。

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

unique_ptr

登录后复制

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

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

尽管

unique_ptr

登录后复制

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

常见误区：

试图直接复制
unique_ptr
登录后复制
：这是最常见的误区。
```
unique_ptr
```
登录后复制
的核心是独占所有权，所以它禁止复制。
```
std::unique_ptr<MyObject> ptr1 = std::make_unique<MyObject>(1);
// std::unique_ptr<MyObject> ptr2 = ptr1; // 编译错误！
```
登录后复制
如果你确实需要转移所有权，必须使用
```
std::move
```
登录后复制
。
对数组使用
unique_ptr<T>
登录后复制
：如果你分配了一个对象数组，比如
```
new MyObject[10]
```
登录后复制
，那么必须使用
```
std::unique_ptr<MyObject[]>
```
登录后复制
来管理它。如果错误地使用了
```
std::unique_ptr<MyObject>
```
登录后复制
，那么在销毁时只会调用
```
delete obj_ptr;
```
登录后复制
而不是
```
delete[] obj_ptr;
```
登录后复制
，这会导致未定义行为，通常是内存泄漏或崩溃。
过度依赖
get()
登录后复制
返回的裸指针：
```
get()
```
登录后复制
方法可以获取
```
unique_ptr
```
登录后复制
内部的裸指针。这在与 C 风格 API 交互时很有用，但如果你将这个裸指针存储起来，而
```
unique_ptr
```
登录后复制
却被销毁了，那么这个裸指针就成了悬空指针。之后再使用它，程序就会崩溃。
```
std::unique_ptr<MyObject> ptr = std::make_unique<MyObject>(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&amp;
```
登录后复制
）通常是更安全的选择。
善用自定义删除器处理特殊资源：
```
unique_ptr
```
登录后复制
不仅仅能管理
```
new/delete
```
登录后复制
的内存，通过自定义删除器，它还能管理文件句柄、网络连接、互斥锁等任何需要明确释放的资源。这使得
```
unique_ptr
```
登录后复制
成为一个通用的 RAII 容器。
```
// 示例见解决方案部分的文件关闭器
```
登录后复制
作为函数参数时，考虑传递引用或裸指针： 如果函数只是需要访问
```
unique_ptr
```
登录后复制
所指向的对象，而不改变其所有权，那么传递
```
MyObject&amp;
```
登录后复制
或
```
MyObject*
```
登录后复制
是更合适的。只有当函数需要接管对象的所有权时，才传递
```
std::unique_ptr<MyObject>
```
登录后复制
。
```
void observeObject(const MyObject&amp; obj) { /* ... */ }
void takeOwnership(std::unique_ptr<MyObject> obj) { /* ... */ }

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