unique_ptr通过独占所有权和RAII机制自动管理内存，避免内存泄漏；它不可复制，只能通过std::move转移所有权，适用于单一所有者场景，性能优于shared_ptr，是现代C++资源管理的首选方案。
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<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." <doSomething(); } // obj 在这里超出作用域，MyObject 会被销毁 std::cout << "Exiting processObject." << std::endl;}int main() { // 1. 使用 std::make_unique 创建 unique_ptr std::unique_ptr<MyObject> ptr1 = std::make_uniquedoSomething(); // 访问对象成员 // 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." <doSomething(); // ptr2 现在拥有对象 // 3. 作为函数返回值 std::unique_ptrdoSomething(); // 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
。
那么，何时选择
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<MyObject> ptr1 = std::make_unique<MyObject>(1);// std::unique_ptr<MyObject> ptr2 = ptr1; // 编译错误！
如果你确实需要转移所有权，必须使用
std::move
。
对数组使用
unique_ptr
： 如果你分配了一个对象数组，比如
new MyObject[10]
，那么必须使用
std::unique_ptr
来管理它。如果错误地使用了
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(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<MyObject>
。
void observeObject(const MyObject& obj) { /* ... */ }void takeOwnership(std::unique_ptr<MyObject> obj) { /* ... */ }// mainstd::unique_ptr<MyObject> ptr = std::make_unique(1);observeObject(*ptr); // 传递引用takeOwnership(std::move(ptr)); // 转移所有权
通过遵循这些实践，你可以充分发挥
unique_ptr
的优势，让你的 C++ 代码更加健壮、安全和易于维护。它确实是现代 C++ 编程中不可或缺的工具。
以上就是C++如何使用unique_ptr管理动态对象的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1475797.html
微信扫一扫 
支付宝扫一扫 
