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 <iostream>
#include <memory>
#include <vector>
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<MyClass> createMyClass() {
return std::make_unique<MyClass>(); // 推荐使用make_unique
}
int main() {
// 独占所有权，不能被复制
std::unique_ptr<MyClass> ptr1 = std::make_unique<MyClass>();
ptr1->doSomething();
// 所有权转移：ptr1的资源转移给ptr2，ptr1变为空
std::unique_ptr<MyClass> ptr2 = std::move(ptr1);
if (ptr1 == nullptr) {
std::cout << "ptr1 is now null after move.\n";
}
ptr2->doSomething();
// 作为函数返回值，实现所有权转移
std::unique_ptr<MyClass> ptr3 = createMyClass();
ptr3->doSomething();
// 将unique_ptr存储在容器中
std::vector<std::unique_ptr<MyClass>> objects;
objects.push_back(std::make_unique<MyClass>());
objects.push_back(std::make_unique<MyClass>());
// 当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 <iostream>
#include <memory>
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<Resource> ptr1 = std::make_shared<Resource>(); // 引用计数为1
std::cout << "ptr1 use_count: " << ptr1.use_count() << "\n";
std::shared_ptr<Resource> ptr2 = ptr1; // 引用计数为2
std::cout << "ptr1 use_count: " << ptr1.use_count() << "\n";
std::cout << "ptr2 use_count: " << ptr2.use_count() << "\n";
{
std::shared_ptr<Resource> 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 <iostream>
#include <memory>
class B; // 前向声明
class A {
public:
std::shared_ptr<B> b_ptr;
A() { std::cout << "A created!\n"; }
~A() { std::cout << "A destroyed!\n"; }
};
class B {
public:
// 这里使用weak_ptr来打破循环引用
std::weak_ptr<A> a_ptr;
B() { std::cout << "B created!\n"; }
~B() { std::cout << "B destroyed!\n"; }
};
int main() {
std::shared_ptr<A> sp_a = std::make_shared<A>();
std::shared_ptr<B> sp_b = std::make_shared<B>();
std::cout << "A use_count: " << sp_a.use_count() << "\n"; // 1
std::cout << "B use_count: " << sp_b.use_count() << "\n"; // 1
sp_a->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() << "\n"; // 2 (因为A持有的b_ptr是shared_ptr)
// 尝试通过weak_ptr访问A
if (auto sharedA = sp_b->a_ptr.lock()) {
std::cout << "A is still alive, use_count: " << sharedA.use_count() << "\n";
} else {
std::cout << "A is gone.\n";
}
// 当sp_a和sp_b离开作用域时，它们各自的引用计数会变为0，对象会被正确销毁
// 如果sp_b->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++现代编程中不可或缺的利器。
暂无评论内容