C++智能指针通过RAII机制自动管理内存，避免泄漏和悬空指针。std::unique_ptr独占所有权，高效安全；std::shared_ptr共享所有权，用引用计数管理生命周期；std::weak_ptr打破循环引用，实现非拥有式观察，三者结合STL容器可简化资源管理。
C++的智能指针，在我看来，是现代C++编程中处理内存管理的一剂良药，它极大地简化了资源管理，尤其是在与STL容器结合使用时，能有效避免内存泄漏和悬空指针等常见问题。它本质上就是一种RAII（Resource Acquisition Is Initialization）的实践，把资源的生命周期与对象的生命周期绑定起来，当对象超出作用域时，资源也自动释放。这比手动管理内存省心太多了，也更安全。
解决方案
在C++中，要妥善管理内存，特别是配合STL容器使用时，智能指针是不可或缺的工具。核心方案是根据所有权模型选择合适的智能指针类型：
std::unique_ptr
、
std::shared_ptr
和
std::weak_ptr
。它们分别对应独占所有权、共享所有权和非拥有观察者模式。通过将动态分配的对象封装在这些智能指针中，当智能指针本身被销毁时，它所管理的对象也会被自动删除，从而避免内存泄漏。对于STL容器，可以直接存储智能指针对象，例如
std::vector<std::unique_ptr>
，这使得容器在析构时能够自动清理其内部存储的所有动态分配的对象，极大地简化了资源管理逻辑。
std::unique_ptr
std::unique_ptr
：独占所有权的内存管理利器
std::unique_ptr
，顾名思义，它代表的是一种独占所有权。也就是说，一个动态分配的对象只能被一个
unique_ptr
实例拥有。我个人非常喜欢用它，因为它几乎没有运行时开销，和裸指针一样高效，但却提供了自动内存管理的安全保障。它不支持拷贝构造和拷贝赋值，这强制你思考资源的所有权转移问题，只能通过移动语义来转移所有权。这在设计上就避免了许多潜在的陷阱，比如双重释放。
它特别适合用在以下场景：
立即学习“C++免费学习笔记（深入）”；
当一个对象只由一个所有者管理，并在所有者销毁时被销毁。作为函数的返回值，表示所有权的转移。在工厂函数中创建对象并返回。作为类成员，管理其内部的动态分配资源。
举个例子，如果你有一个
std::vector
，里面存放的元素是动态创建的，并且你希望每个元素都由
vector
独占管理，那么
std::vector<std::unique_ptr>
就是完美的解决方案。当
vector
被销毁时，它会负责调用每个
unique_ptr
的析构函数，进而释放所有
MyClass
对象占用的内存。这比你手动遍历
vector
然后
delete
每个元素要安全和简洁得多，也更容易维护。
#include #include // For std::unique_ptr#include class MyResource {public: MyResource(int id) : id_(id) { std::cout << "MyResource " << id_ << " constructed." << std::endl; } ~MyResource() { std::cout << "MyResource " << id_ << " destructed." << std::endl; } void doSomething() { std::cout << "MyResource " << id_ << " doing something." << std::endl; }private: int id_;};// 示例：unique_ptr 作为函数返回值，转移所有权std::unique_ptr createResource(int id) { return std::make_unique(id);}int main() { // 独占所有权示例 std::unique_ptr res1 = std::make_unique(1); res1->doSomething(); // 所有权转移 std::unique_ptr res2 = std::move(res1); // res1 变为空 if (res1) { std::cout << "res1 still holds resource." << std::endl; } else { std::cout << "res1 no longer holds resource." <doSomething(); // unique_ptr 和 STL 容器 std::vector<std::unique_ptr> resources; resources.push_back(std::make_unique(3)); resources.push_back(createResource(4)); // 函数返回 unique_ptr for (const auto& r_ptr : resources) { r_ptr->doSomething(); } // main 函数结束时，res2 和 resources 中的 MyResource 对象都会被自动销毁 std::cout << "End of main function." << std::endl; return 0;}
std::shared_ptr
std::shared_ptr
：处理共享所有权的理想选择
当多个对象需要共享同一个资源的生命周期时，
std::shared_ptr
就派上用场了。它通过引用计数（reference counting）机制来管理内存：每当有一个
shared_ptr
指向同一个资源时，引用计数就增加；当一个
shared_ptr
被销毁或重新指向其他资源时，引用计数就减少。当引用计数归零时，表示没有
shared_ptr
再引用该资源，资源就会被自动释放。这解决了多方协同管理资源生命周期的难题。
shared_ptr
的优势在于其灵活性，但随之而来的也有一些需要注意的地方。引用计数会带来一定的运行时开销，而且如果设计不当，可能会导致循环引用（circular reference），进而造成内存泄漏。这是使用
shared_ptr
时最常见也最需要警惕的问题。
它适用于：
多个对象需要共同拥有并管理一个资源的生命周期。在复杂对象图中，资源需要在不同部分之间共享。
比如，你有一个缓存系统，多个客户端可能会访问同一个数据对象。每个客户端都持有一个
shared_ptr
，当所有客户端都不再需要这个数据时，它就会被自动清理。这比手动追踪哪个客户端是最后一个使用者要方便得多。
#include #include // For std::shared_ptr#include class SharedResource {public: SharedResource(int id) : id_(id) { std::cout << "SharedResource " << id_ << " constructed." << std::endl; } ~SharedResource() { std::cout << "SharedResource " << id_ << " destructed." << std::endl; } void use() { std::cout << "SharedResource " << id_ << " is being used. Current ref count: " << shared_from_this().use_count() << std::endl; }private: int id_;};int main() { std::shared_ptr s_res1 = std::make_shared(100); std::cout << "s_res1 ref count: " << s_res1.use_count() << std::endl; std::shared_ptr s_res2 = s_res1; // 拷贝，引用计数增加 std::cout << "s_res1 ref count: " << s_res1.use_count() << std::endl; std::cout << "s_res2 ref count: " << s_res2.use_count() << std::endl; { std::shared_ptr s_res3 = s_res1; // 再次拷贝 std::cout << "s_res1 ref count: " << s_res1.use_count() <use(); } // s_res3 离开作用域，引用计数减少 std::cout << "s_res1 ref count after s_res3 out of scope: " << s_res1.use_count() << std::endl; // shared_ptr 和 STL 容器 std::vector<std::shared_ptr> shared_resources_vec; shared_resources_vec.push_back(s_res1); // s_res1 再次被拷贝 shared_resources_vec.push_back(std::make_shared(200)); std::cout << "s_res1 ref count after vector push_back: " << s_res1.use_count() << std::endl; // main 函数结束时，所有 SharedResource 对象都会在引用计数归零时被销毁 std::cout << "End of main function." << std::endl; return 0;}
std::weak_ptr
std::weak_ptr
：打破循环引用的关键与非拥有观察
std::weak_ptr
是
std::shared_ptr
的辅助工具，它不拥有所指向的对象，因此不会增加对象的引用计数。它的主要作用是观察
shared_ptr
管理的对象，而不会阻止该对象被销毁。这在处理
shared_ptr
可能导致的循环引用问题时显得尤为重要。
当两个或多个对象通过
shared_ptr
相互引用时，它们的引用计数永远不会归零，导致它们永远不会被销毁，这就是循环引用。
weak_ptr
通过提供一种非拥有式的引用，打破了这种循环。一个对象可以通过
shared_ptr
拥有另一个对象，而另一个对象则通过
weak_ptr
观察第一个对象。当第一个对象被销毁时，
weak_ptr
会自动失效，因为它观察的对象已经不存在了。
要访问
weak_ptr
指向的对象，你需要先调用它的
lock()
方法，该方法会返回一个
std::shared_ptr
。如果对象仍然存在，
lock()
会返回一个有效的
shared_ptr
；否则，它会返回一个空的
shared_ptr
。这提供了一种安全的方式来检查对象是否仍然存活。
使用场景：
打破
shared_ptr
造成的循环引用。实现缓存机制，其中缓存项可以在不被引用时自动过期。在父子关系中，子节点持有父节点的
shared_ptr
，而父节点持有子节点的
weak_ptr
。
说实话，刚接触
weak_ptr
时，觉得它有点绕，不如
unique_ptr
和
shared_ptr
那么直观。但一旦你遇到循环引用，或者需要设计一个观察者模式，但又不希望观察者“拥有”被观察者，
weak_ptr
的价值就凸显出来了。它是构建健壮、复杂对象关系图的关键一环。
#include #include // For std::shared_ptr, std::weak_ptrclass B; // 前向声明class A {public: std::shared_ptr b_ptr; A() { std::cout << "A constructed." << std::endl; } ~A() { std::cout << "A destructed." << std::endl; } void link(std::shared_ptr b) { b_ptr = b; }};class B {public: std::weak_ptr a_ptr; // 使用 weak_ptr 打破循环 B() { std::cout << "B constructed." << std::endl; } ~B() { std::cout << "B destructed." << std::endl; } void link(std::shared_ptr a) { a_ptr = a; } void accessA() { if (auto sp = a_ptr.lock()) { // 尝试获取 shared_ptr std::cout << "B can access A." << std::endl; } else { std::cout << "A no longer exists." << std::endl; } }};int main() { std::cout << "--- 循环引用问题（使用 weak_ptr 解决） ---" << std::endl; { std::shared_ptr my_a = std::make_shared(); std::shared_ptr my_b = std::make_shared(); // 相互引用 my_a->link(my_b); my_b->link(my_a); std::cout << "my_a ref count: " << my_a.use_count() << std::endl; // 应该是 1 (my_a自己) std::cout << "my_b ref count: " << my_b.use_count() <b_ptr) my_b->accessA(); // 此时 A 仍然存在 } // my_a 和 my_b 离开作用域 std::cout << "--- 离开作用域后，对象是否被销毁？ ---" << std::endl; // 由于 B 中使用了 weak_ptr，A 的引用计数会归零，A 会被销毁。 // A 销毁后，其持有的 B 的 shared_ptr 也会失效，B 的引用计数归零，B 也会被销毁。 // 如果 B 中也用 shared_ptr，则 A 和 B 都不会被销毁。 // 再次尝试访问已销毁的 A std::shared_ptr expired_a; std::shared_ptr observer_b = std::make_shared(); observer_b->link(expired_a); // link to a null shared_ptr observer_b->accessA(); // 应该输出 "A no longer exists." std::cout << "End of main function." << std::endl; return 0;}
以上就是C++智能指针 STL内存管理方案的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1472612.html
微信扫一扫 
支付宝扫一扫 
