c++++中的智能指针通过raii机制自动管理内存，避免内存泄漏等问题。1. unique_ptr强调独占所有权，不可复制，支持移动语义，适用于对象仅由一处管理的场景；2. shared_ptr通过引用计数实现共享所有权，多个指针可同时管理同一资源，但需注意循环引用和性能开销；3. weak_ptr作为弱引用不增加引用计数，用于打破shared_ptr的循环引用，适用于观察者或缓存机制。它们共同构成现代c++内存管理的核心工具。
C++中的智能指针，简单来说，就是一种行为类似于指针，但能自动管理内存的类模板。它们的核心价值在于通过RAII（资源获取即初始化）原则，帮助我们避免手动管理内存时常遇到的内存泄漏、野指针和二次释放等问题。这玩意儿简直是现代C++编程的基石，少了它，很多代码写起来都提心吊胆的。
智能指针的出现，彻底改变了我们处理动态内存的方式。它不是什么魔法，本质上就是个封装了原始指针的类，在对象生命周期结束时，自动调用析构函数来释放其管理的内存。这听起来可能有点抽象，但想想看，每次new一个对象后，你是不是总得记得delete它？如果中间抛了异常，或者逻辑分支复杂了，很容易就忘了delete，内存泄漏就发生了。智能指针就是来解决这个痛点的，它确保了资源（这里主要是内存）在不再需要时，会被妥善地释放掉。这就像你租了个房子，智能指针就是那个自动帮你退房、打扫干净的管家，你只管住，不用操心后续。
unique_ptr 到底“独”在哪里？它有哪些典型的使用场景？
unique_ptr，顾名思义，它强调的是“独占”所有权。这意味着一个unique_ptr对象拥有它所指向资源（比如一块内存）的唯一所有权。这东西是不能被复制的，你不能有两个unique_ptr同时指向同一块内存，因为那样就乱套了，谁来负责释放呢？它只支持移动语义，也就是说，所有权可以从一个unique_ptr转移给另一个，但转移之后，原来的那个unique_ptr就不再拥有资源了，它会变成空的。
立即学习“C++免费学习笔记（深入）”；
这种独占性让unique_ptr在很多场景下都显得非常有用。比如说，当你需要一个对象，并且明确知道这个对象只会被一个地方拥有和管理时，unique_ptr就是最佳选择。比如一个函数创建了一个新对象，然后把这个对象的管理权“移交”给调用者。
#include #include #include class MyClass {public: MyClass() { std::cout << "MyClass created!n"; } ~MyClass() { std::cout << "MyClass destroyed!n"; } void doSomething() { std::cout << "Doing something...n"; }};// 函数返回一个独占所有权的MyClass对象std::unique_ptr createMyClass() { return std::make_unique(); // 推荐使用make_unique}int main() { // 独占所有权，不能被复制 std::unique_ptr ptr1 = std::make_unique(); ptr1->doSomething(); // 所有权转移：ptr1的资源转移给ptr2，ptr1变为空 std::unique_ptr ptr2 = std::move(ptr1); if (ptr1 == nullptr) { std::cout <doSomething(); // 作为函数返回值，实现所有权转移 std::unique_ptr ptr3 = createMyClass(); ptr3->doSomething(); // 将unique_ptr存储在容器中 std::vector<std::unique_ptr> objects; objects.push_back(std::make_unique()); objects.push_back(std::make_unique()); // 当objects超出作用域时，其中的MyClass对象都会被自动销毁 // ptr2和ptr3在main函数结束时会自动销毁其管理的MyClass对象 return 0;}
你看，unique_ptr的开销几乎为零，因为它不需要维护引用计数什么的，和原始指针一样高效。它在编译期就能保证内存安全，一旦所有权转移，原指针就失效了，这在逻辑上非常清晰。
shared_ptr 是如何实现共享所有权的？它又带来哪些潜在的问题？
shared_ptr则完全是另一种哲学，它实现了“共享”所有权。这意味着多个shared_ptr对象可以同时指向并管理同一块内存。它通过一个内部的引用计数（reference count）机制来工作：每当一个新的shared_ptr指向同一个资源时，引用计数就加一；每当一个shared_ptr离开作用域或者不再指向该资源时，引用计数就减一。只有当引用计数归零时，shared_ptr才会释放它所管理的内存。这就像一个公共图书馆的书，大家都可以借阅，只要还有人在借，书就不会被扔掉。
#include #include class Resource {public: Resource() { std::cout << "Resource created!n"; } ~Resource() { std::cout << "Resource destroyed!n"; } void use() { std::cout << "Using resource...n"; }};int main() { std::shared_ptr ptr1 = std::make_shared(); // 引用计数为1 std::cout << "ptr1 use_count: " << ptr1.use_count() << "n"; std::shared_ptr ptr2 = ptr1; // 引用计数为2 std::cout << "ptr1 use_count: " << ptr1.use_count() << "n"; std::cout << "ptr2 use_count: " << ptr2.use_count() << "n"; { std::shared_ptr ptr3 = ptr1; // 引用计数为3 std::cout << "ptr1 use_count (inside scope): " << ptr1.use_count() << "n"; } // ptr3离开作用域，引用计数减1，变为2 std::cout << "ptr1 use_count (after ptr3 scope): " << ptr1.use_count() << "n"; ptr1.reset(); // ptr1不再指向资源，引用计数减1，变为1 std::cout << "ptr2 use_count (after ptr1 reset): " << ptr2.use_count() << "n"; // 当ptr2离开作用域时，引用计数变为0，Resource被销毁 return 0;}
shared_ptr的便利性毋庸置疑，尤其是在对象生命周期复杂，有多个地方需要访问同一个对象时。但它也带来了几个潜在的问题，其中最臭名昭著的就是“循环引用”（circular reference）。如果两个或多个shared_ptr相互持有对方的shared_ptr，就会形成一个闭环。在这种情况下，即使外部已经没有其他shared_ptr指向它们了，它们的引用计数也永远不会降到零，导致它们所管理的内存永远不会被释放，这就造成了内存泄漏。
此外，shared_ptr相比unique_ptr会带来一些性能开销。因为它需要维护一个引用计数，这个计数器通常是原子操作，以保证多线程环境下的正确性。原子操作比普通操作要慢，虽然在大多数情况下这点开销可以忽略不计，但在性能敏感的场景下，也需要考虑。
weak_ptr 的存在意义是什么？它如何解决 shared_ptr 的循环引用问题？
weak_ptr就是为了解决shared_ptr的循环引用问题而诞生的。它是一种“弱引用”或者说“非拥有”的智能指针。weak_ptr可以指向一个由shared_ptr管理的对象，但它不会增加对象的引用计数。这就像一个观察者，它知道有这本书在那里，但它并没有借阅这本书，所以它不会影响书的借阅计数。
因为weak_ptr不拥有资源，所以它不能直接访问资源。要访问它指向的对象，你必须先调用它的lock()方法，lock()会尝试返回一个shared_ptr。如果它指向的对象还存在（即其shared_ptr的引用计数不为零），lock()就会成功返回一个shared_ptr；如果对象已经被销毁了（因为所有shared_ptr都已失效），lock()就会返回一个空的shared_ptr。通过这种方式，weak_ptr提供了一种安全地访问共享对象的方式，同时又不会阻止对象的销毁。
#include #include class B; // 前向声明class A {public: std::shared_ptr b_ptr; A() { std::cout << "A created!n"; } ~A() { std::cout << "A destroyed!n"; }};class B {public: // 这里使用weak_ptr来打破循环引用 std::weak_ptr a_ptr; B() { std::cout << "B created!n"; } ~B() { std::cout << "B destroyed!n"; }};int main() { std::shared_ptr sp_a = std::make_shared(); std::shared_ptr sp_b = std::make_shared(); std::cout << "A use_count: " << sp_a.use_count() << "n"; // 1 std::cout << "B use_count: " << sp_b.use_count() <b_ptr = sp_b; // A持有B的shared_ptr，B的引用计数变为2 // sp_b->a_ptr = sp_a; // 如果这里也用shared_ptr，就形成循环引用了 // 使用weak_ptr来持有A，不会增加A的引用计数 sp_b->a_ptr = sp_a; std::cout << "After linking:n"; std::cout << "A use_count: " << sp_a.use_count() << "n"; // 1 (因为B持有的a_ptr是weak_ptr) std::cout << "B use_count: " << sp_b.use_count() <a_ptr.lock()) { std::cout << "A is still alive, use_count: " << sharedA.use_count() << "n"; } else { std::cout <a_ptr也是shared_ptr，那么sp_a和sp_b的引用计数永远是1，不会销毁 return 0;}
在这个例子里，A拥有一个B的shared_ptr，而B则拥有一个A的weak_ptr。当main函数结束，sp_a和sp_b离开作用域时，sp_a的引用计数首先降为0，A对象被销毁。接着，sp_b的引用计数也降为0，B对象被销毁。整个过程没有内存泄漏。如果没有weak_ptr，A和B就会互相牵制，导致内存泄露。
weak_ptr主要用于那些“观察者”模式或者缓存机制中，你希望能够访问一个对象，但又不希望你的存在影响这个对象的生命周期。它提供了一种优雅的方式来处理复杂的对象依赖关系，避免了shared_ptr固有的循环引用陷阱。理解并恰当使用这三种智能指针，是写出健壮、高效C++代码的关键一步。它们虽然不能解决所有内存管理问题（比如循环引用就需要weak_ptr来辅助），但绝对是C++现代编程中不可或缺的利器。
以上就是什么是C++中的智能指针 详解unique_ptr shared_ptr weak_ptr用法的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1468035.html
微信扫一扫 
支付宝扫一扫 
