C++智能指针通过RAII管理动态内存，避免泄漏与野指针。std::unique_ptr独占所有权，高效无开销，适用于单一所有者场景；std::shared_ptr共享所有权，用引用计数控制生命周期，适合多所有者共享资源；std::weak_ptr作为弱引用不增计数，解决shared_ptr循环引用问题，常用于观察者或缓存。三者结合可安全高效管理堆资源。
C++中，智能指针是管理动态资源（主要是堆内存）的强大工具，它们通过RAII（资源获取即初始化）原则，自动化了内存的生命周期管理，从而有效避免了内存泄漏、野指针和重复释放等常见问题。在我看来，它们是现代C++编程中不可或缺的基石，极大提升了代码的健壮性和可维护性。
解决方案
要有效管理C++中的动态资源，核心在于使用标准库提供的三种智能指针：
std::unique_ptr、
std::shared_ptr和
std::weak_ptr。它们各自拥有不同的所有权语义，适用于不同的场景。简单来说，
unique_ptr强调独占，资源只能有一个所有者；
shared_ptr允许多个所有者共享资源，通过引用计数来管理生命周期；而
weak_ptr则是一种不拥有资源的观察者，主要用于解决
shared_ptr的循环引用问题。理解并合理运用这三者，几乎可以解决所有基于堆内存的资源管理难题。
std::unique_ptr
：独占所有权的效率之选？
std::unique_ptr，顾名思义，它代表的是对资源的独占所有权。这意味着一个
unique_ptr实例是它所管理资源的唯一所有者。一旦
unique_ptr超出作用域，它所指向的资源就会被自动释放。我个人觉得，这种设计简洁而高效，因为它不需要维护引用计数，几乎没有运行时开销，性能上与裸指针无异。
它的一个显著特点是不可复制，只能通过
std::move进行所有权的转移。这非常符合“独占”的语义。比如，你有一个函数需要创建一个对象并返回给调用者，但这个对象的所有权应该转移给调用者，这时
unique_ptr就派上用场了。
立即学习“C++免费学习笔记（深入）”；
#include <iostream>
#include <memory>
#include <string>
class MyResource {
public:
MyResource(const std::string& name) : name_(name) {
std::cout << "MyResource " << name_ << " created." << std::endl;
}
~MyResource() {
std::cout << "MyResource " << name_ << " destroyed." << std::endl;
}
void doSomething() {
std::cout << "MyResource " << name_ << " is doing something." << std::endl;
}
private:
std::string name_;
};
// 函数返回一个unique_ptr，所有权转移给调用方
std::unique_ptr<MyResource> createResource(const std::string& name) {
return std::make_unique<MyResource>(name); // 推荐使用make_unique
}
int main() {
std::cout << "--- unique_ptr example ---" << std::endl;
std::unique_ptr<MyResource> res1 = createResource("A");
res1->doSomething();
// 尝试复制会编译错误：std::unique_ptr<MyResource> res2 = res1;
// 所有权转移
std::unique_ptr<MyResource> res2 = std::move(res1);
if (res1 == nullptr) { // res1现在为空
std::cout << "res1 is now empty after move." << std::endl;
}
res2->doSomething();
// 当res2超出作用域时，MyResource "A" 将被销毁
std::cout << "--- unique_ptr example end ---" << std::endl;
return 0;
}在我看来，
std::make_unique是创建
unique_ptr的最佳实践，它能保证异常安全，并且通常比直接
new然后包装更高效。
unique_ptr特别适合那些明确知道资源只有一个所有者的场景，比如文件句柄、网络连接或者一些工厂模式的返回值。
std::shared_ptr
：共享资源的协作模式？
聊完了独占的
unique_ptr，自然就得说说那更复杂、但同样不可或缺的
std::shared_ptr了。当多个对象需要共享同一份资源时，
shared_ptr就是你的不二选择。它通过内部维护一个引用计数器来追踪有多少个
shared_ptr实例正在指向同一个资源。只有当最后一个
shared_ptr实例被销毁或重置时，它所管理的资源才会被释放。
这种共享所有权模型非常灵活，尤其在实现一些复杂的数据结构或设计模式时显得尤为重要，比如图结构中的节点、观察者模式中的主题等。我常遇到需要多个模块共同持有某个配置对象或数据缓存的情况，这时候
shared_ptr就显得游刃有余。
#include <iostream>
#include <memory>
#include <string>
#include <vector>
class SharedResource {
public:
SharedResource(const std::string& id) : id_(id) {
std::cout << "SharedResource " << id_ << " created." << std::endl;
}
~SharedResource() {
std::cout << "SharedResource " << id_ << " destroyed." << std::endl;
}
void report() {
std::cout << "SharedResource " << id_ << " is active." << std::endl;
}
private:
std::string id_;
};
int main() {
std::cout << "--- shared_ptr example ---" << std::endl;
std::shared_ptr<SharedResource> s_res1 = std::make_shared<SharedResource>("X");
s_res1->report();
std::cout << "Reference count for X: " << s_res1.use_count() << std::endl;
// 复制shared_ptr，引用计数增加
std::shared_ptr<SharedResource> s_res2 = s_res1;
std::cout << "Reference count for X: " << s_res1.use_count() << std::endl;
// 放入容器中，引用计数再次增加
std::vector<std::shared_ptr<SharedResource>> resources;
resources.push_back(s_res1);
std::cout << "Reference count for X: " << s_res1.use_count() << std::endl;
// s_res2超出作用域，引用计数减少
{
std::shared_ptr<SharedResource> s_res3 = s_res1;
std::cout << "Reference count for X: " << s_res1.use_count() << std::endl;
} // s_res3销毁
std::cout << "Reference count for X: " << s_res1.use_count() << std::endl;
// 当所有shared_ptr实例都销毁后，SharedResource "X" 才会被销毁
std::cout << "--- shared_ptr example end ---" << std::endl;
return 0;
}和
unique_ptr类似，
std::make_shared是创建
shared_ptr的首选方式。它不仅能提供异常安全，还能优化内存分配，将对象本身和其管理块（包含引用计数等信息）一次性分配，减少了内存碎片。不过，
shared_ptr并非没有缺点，它的主要开销在于需要维护引用计数，这会带来一些性能损耗。更重要的是，它可能会引入一个非常棘手的问题：循环引用。
std::weak_ptr
：打破循环引用的观察者？
这玩意儿，
std::weak_ptr，我觉得是智能指针家族里最“低调”但又最关键的一员。它不拥有资源，仅仅是
std::shared_ptr的一个“观察者”或者说“弱引用”。
weak_ptr不会增加资源的引用计数，因此它的存在不会阻止资源被释放。这使得它成为解决
shared_ptr循环引用问题的完美方案。
什么是循环引用？想象一下，对象A有一个
shared_ptr指向对象B，同时对象B也有一个
shared_ptr指向对象A。这样一来，即使外部已经没有其他
shared_ptr指向A或B，它们的引用计数永远不会降到零，导致它们永远不会被销毁，造成内存泄漏。这简直是C++程序员的噩梦，但好在标准库给了我们解药。
weak_ptr通过
lock()方法可以尝试获取一个
shared_ptr。如果资源仍然存在（即还有其他
shared_ptr持有它），
lock()会返回一个有效的
shared_ptr；否则，它会返回一个空的
shared_ptr。
#include <iostream>
#include <memory>
#include <string>
class B; // 前向声明
class A {
public:
std::shared_ptr<B> b_ptr;
A() { std::cout << "A created." << std::endl; }
~A() { std::cout << "A destroyed." << std::endl; }
};
class B {
public:
// 使用weak_ptr打破循环引用
std::weak_ptr<A> a_ptr;
B() { std::cout << "B created." << std::endl; }
~B() { std::cout << "B destroyed." << std::endl; }
void checkA() {
if (auto shared_a = a_ptr.lock()) { // 尝试获取shared_ptr
std::cout << "B can access A." << std::endl;
} else {
std::cout << "A has been destroyed." << std::endl;
}
}
};
int main() {
std::cout << "--- weak_ptr breaking circular reference example ---" << std::endl;
std::shared_ptr<A> a = std::make_shared<A>();
std::shared_ptr<B> b = std::make_shared<B>();
// 建立循环引用
a->b_ptr = b;
b->a_ptr = a; // 这里使用weak_ptr
std::cout << "A's ref count: " << a.use_count() << std::endl; // 1 (b_ptr持有B，B的weak_ptr不影响A的计数)
std::cout << "B's ref count: " << b.use_count() << std::endl; // 1 (a_ptr持有A)
b->checkA(); // B可以访问A
// 当a和b超出作用域时，它们将分别被销毁
// 如果B中a_ptr也是shared_ptr，这里不会调用析构函数
std::cout << "--- weak_ptr example end ---" << std::endl;
return 0;
}除了解决循环引用，
weak_ptr在实现缓存、观察者模式或者任何需要“非拥有”地访问某个资源的场景都非常有用。它允许你观察一个对象，而不会影响它的生命周期。说实话，我个人觉得，理解
weak_ptr的使用场景和机制，是掌握
shared_ptr高级用法的关键一步。
总而言之，C++智能指针是现代C++内存管理的核心。
unique_ptr用于独占资源，高效简洁；
shared_ptr用于共享资源，灵活方便；
weak_ptr则作为
shared_ptr的补充，解决循环引用并提供非拥有观察能力。合理搭配使用它们，能让你的C++代码更安全、更健壮。
