c++++智能指针主要有unique_ptr、shared_ptr和weak_ptr三种类型，它们基于raii原则实现自动化内存管理，避免内存泄漏和悬空指针问题；unique_ptr提供独占所有权且高效，适用于单一所有者场景；shared_ptr通过引用计数实现共享所有权，适合多对象共用资源的情况；weak_ptr作为弱引用不增加引用计数，用于打破shared_ptr的循环引用并安全观察对象生命周期，三者结合使用可显著提升c++程序的内存安全与代码健壮性。
C++智能指针主要有三种类型：
unique_ptr
、
shared_ptr
和
weak_ptr
。它们的核心作用在于自动化内存管理，极大简化了C++中资源生命周期的控制，有效避免了内存泄漏和悬空指针等问题。简单来说，它们让C++的内存管理变得更安全、更省心。
解决方案
说实话，刚接触C++那会儿，手动管理内存真是个噩梦。
new
了就得记得
delete
，稍微一疏忽，内存泄漏就找上门，程序崩溃更是家常便饭。直到智能指针的出现，才感觉C++在现代编程语言的内存管理上真正迈出了一大步。它们并非什么魔法，而是基于RAII（Resource Acquisition Is Initialization）原则，也就是资源在对象构造时获取，在对象析构时释放。这就像是给内存资源套上了一层“自动回收器”，当智能指针对象超出作用域时，它所管理的内存也会被自动释放掉，省去了我们手动
delete
的烦恼。
这三种智能指针各司其职，解决了不同场景下的内存所有权问题。
unique_ptr
强调独占，
shared_ptr
实现共享，而
weak_ptr
则像是旁观者，用于解决
shared_ptr
可能带来的循环引用问题。理解它们各自的特点和适用场景，是写出健壮C++代码的关键一步。
立即学习“C++免费学习笔记（深入）”；
unique_ptr
unique_ptr
的独特所有权与高效管理
unique_ptr
，顾名思义，它拥有对所指向对象的“独占”所有权。这意味着在任何时间点，一个特定的对象只能被一个
unique_ptr
拥有。这种所有权是不能被复制的，但可以被“移动”。我个人觉得，
unique_ptr
是日常开发中最常用也最推荐的智能指针，因为它几乎没有运行时开销，跟原始指针一样高效，却提供了自动释放内存的便利。
它特别适合那些资源必须有且只有一个明确所有者的场景，比如文件句柄、网络连接、或者某个类的内部成员，这些资源一旦被创建，就应该由某个特定的实体负责其生命周期。当你需要将资源的所有权从一个地方转移到另一个地方时，
std::move
就派上用场了。
#include #include #include class MyResource {public: MyResource(int id) : id_(id) { std::cout << "MyResource " << id_ << " created." << std::endl; } ~MyResource() { std::cout << "MyResource " << id_ << " destroyed." << std::endl; } void do_something() { std::cout << "MyResource " << id_ << " doing something." << std::endl; }private: int id_;};void process_resource(std::unique_ptr res) { if (res) { // 检查是否为空 res->do_something(); } // res 在这里超出作用域，MyResource 自动销毁}int main() { // 创建一个 unique_ptr std::unique_ptr ptr1 = std::make_unique(1); ptr1->do_something(); // 尝试复制会编译错误： // std::unique_ptr ptr2 = ptr1; // 编译错误 // 移动所有权 std::unique_ptr ptr2 = std::move(ptr1); if (!ptr1) { // ptr1 现在是空的 std::cout << "ptr1 is now empty after move." <do_something(); // 将所有权传递给函数 process_resource(std::move(ptr2)); if (!ptr2) { std::cout << "ptr2 is now empty after passing to function." << std::endl; } // 在容器中使用 unique_ptr std::vector<std::unique_ptr> resources; resources.push_back(std::make_unique(3)); resources.push_back(std::make_unique(4)); // 当 resources 向量超出作用域时，其中的 MyResource 对象也会自动销毁 std::cout << "Main function ending." << std::endl; return 0;}
使用
std::make_unique
来创建
unique_ptr
是个好习惯，它能避免一些潜在的异常安全问题，并且通常效率更高，因为它只进行一次内存分配。
shared_ptr
shared_ptr
如何实现共享所有权与引用计数
有时候，一个资源可能需要被多个地方共同拥有，比如一个配置对象，或者一个大的数据结构，多个模块都需要访问它，并且当最后一个使用者不再需要它时，它才应该被销毁。这时，
shared_ptr
就派上用场了。
shared_ptr
通过引用计数（reference counting）机制来实现共享所有权：每当有一个新的
shared_ptr
指向同一个对象时，引用计数就增加；当一个
shared_ptr
被销毁或指向其他对象时，引用计数就减少。当引用计数归零时，
shared_ptr
会自动删除它所管理的对象。
这种机制听起来很方便，确实也解决了许多复杂场景下的内存管理问题。比如在构建图结构、观察者模式或者缓存系统时，
shared_ptr
能让逻辑变得清晰很多。
#include #include #include class SharedResource {public: SharedResource(int id) : id_(id) { std::cout << "SharedResource " << id_ << " created." << std::endl; } ~SharedResource() { std::cout << "SharedResource " << id_ << " destroyed." << std::endl; } void use() { std::cout << "SharedResource " << id_ << " is being used." << std::endl; }private: int id_;};int main() { std::shared_ptr ptrA = std::make_shared(100); std::cout << "ptrA ref count: " << ptrA.use_count() << std::endl; // 1 std::shared_ptr ptrB = ptrA; // 复制所有权 std::cout << "ptrA ref count: " << ptrA.use_count() << std::endl; // 2 std::cout << "ptrB ref count: " << ptrB.use_count() << std::endl; // 2 { std::shared_ptr ptrC = ptrA; // 再次复制 std::cout << "ptrA ref count: " << ptrA.use_count() <use(); } // ptrC 超出作用域，引用计数减1 std::cout << "ptrA ref count after C out of scope: " << ptrA.use_count() << std::endl; // 2 ptrB.reset(); // ptrB 放弃所有权，引用计数减1 std::cout << "ptrA ref count after B reset: " << ptrA.use_count() << std::endl; // 1 // 当 ptrA 超出作用域时，引用计数变为0，SharedResource 100 被销毁 std::cout << "Main function ending." << std::endl; return 0;}
同样，
std::make_shared
是创建
shared_ptr
的首选方式，因为它能在一个内存块中同时分配对象本身和引用计数器，这比先
new
对象再用
shared_ptr
管理要高效得多。不过，
shared_ptr
也有它的缺点，最主要的就是循环引用问题，这正是
weak_ptr
存在的理由。
weak_ptr
weak_ptr
为何能打破循环引用并安全观察
shared_ptr
虽然强大，但它有一个著名的“坑”：循环引用。如果两个或多个
shared_ptr
相互持有对方的引用，那么它们的引用计数永远不会降到零，导致内存泄漏。比如，对象A有一个
shared_ptr
指向B，对象B有一个
shared_ptr
指向A，它们会形成一个死循环，谁也无法释放。
weak_ptr
就是为了解决这个问题而生的。它是一种不拥有对象所有权的智能指针，它只是对
shared_ptr
所管理对象的一个“弱引用”或者说“观察者”。
weak_ptr
不会增加对象的引用计数，所以它不会阻止对象被销毁。当你需要访问
weak_ptr
所指向的对象时，你需要先调用它的
lock()
方法，尝试获取一个
shared_ptr
。如果对象仍然存在，
lock()
会返回一个有效的
shared_ptr
；如果对象已经被销毁，它会返回一个空的
shared_ptr
。
这使得
weak_ptr
非常适合用于那些需要访问但又不能拥有所有权的场景，比如缓存管理器（缓存项不应该阻止自身被清理）、父子关系（子节点可以强引用父节点，但父节点对子节点使用弱引用，避免循环）、或者观察者模式中观察者对被观察者的引用。
#include #include class B; // 前向声明class A {public: std::shared_ptr b_ptr; A() { std::cout << "A created." << std::endl; } ~A() { std::cout << "A destroyed." << std::endl; }};class B {public: std::weak_ptr a_ptr; // 使用 weak_ptr 避免循环引用 B() { std::cout << "B created." << std::endl; } ~B() { std::cout << "B destroyed." << std::endl; } void check_a() { if (auto sharedA = a_ptr.lock()) { // 尝试获取 shared_ptr std::cout << "B can still access A." << std::endl; } else { std::cout << "A has been destroyed." << std::endl; } }};int main() { std::cout << "--- Demonstrating shared_ptr circular reference (conceptual) ---" << std::endl; // 如果这里 A 和 B 都用 shared_ptr 互相引用，它们将永远不会被销毁 // std::shared_ptr a = std::make_shared(); // std::shared_ptr b = std::make_shared(); // a->b_ptr = b; // b->a_ptr = a; // 引用计数永远不会归零 std::cout << "n--- Demonstrating weak_ptr breaking circular reference ---" << std::endl; std::shared_ptr a_obj = std::make_shared(); std::shared_ptr b_obj = std::make_shared(); a_obj->b_ptr = b_obj; // A 强引用 B b_obj->a_ptr = a_obj; // B 弱引用 A std::cout << "A ref count: " << a_obj.use_count() <a_ptr 不增加引用计数) std::cout << "B ref count: " << b_obj.use_count() <b_ptr 和 b_obj 自身) b_obj->check_a(); // A 还在，可以访问 // 销毁 a_obj a_obj.reset(); std::cout << "A ref count after reset: " << (a_obj ? a_obj.use_count() : 0) << std::endl; // 0 std::cout << "B ref count after A reset: " << b_obj.use_count() <check_a(); // A 已经销毁，无法访问 std::cout << "Main function ending." << std::endl; return 0;}
通过
weak_ptr
，我们可以安全地检查对象是否存在，并在需要时临时提升为
shared_ptr
进行操作，避免了内存泄漏的风险。这在设计复杂的、相互关联的对象系统时，显得尤为重要。
总结一下，C++的智能指针家族为我们提供了强大的工具来管理动态内存。
unique_ptr
是默认首选，用于独占所有权；
shared_ptr
用于共享所有权，但要小心循环引用；而
weak_ptr
则是
shared_ptr
的完美搭档，用于打破循环引用并安全地观察对象生命周期。理解并恰当使用它们，能让我们的C++代码更加健壮和高效。
以上就是C++智能指针有哪些类型 unique_ptr shared_ptr weak_ptr用法的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1473540.html
微信扫一扫 
支付宝扫一扫 
