c++++智能指针通过raii机制自动管理内存，避免内存泄漏。1. unique_ptr实现独占式所有权，确保同一时间只有一个指针指向对象，支持显式转移所有权，适用于资源管理和工厂函数返回值；2. shared_ptr采用引用计数实现共享所有权，最后一个shared_ptr销毁时释放对象，适合多指针共享资源的场景，并可结合weak_ptr解决循环引用；3. weak_ptr提供弱引用，不增加引用计数，用于观察对象状态或打破shared_ptr间的循环引用；4. 推荐使用make_shared创建shared_ptr，提升异常安全性和性能；5. 多线程环境下shared_ptr线程安全但对象访问需同步，unique_ptr非线程安全；6. 自定义删除器可用于释放非内存资源或执行特定清理操作；7. 选择智能指针时需权衡所有权模型、性能及线程安全等因素，慎用与原始指针的交互以避免重复释放或悬挂指针问题。
c++智能指针本质上是为了更好地管理动态分配的内存，避免内存泄漏。它们通过RaiI（Resource Acquisition Is Initialization）机制，在对象生命周期结束时自动释放资源。
unique_ptr、shared_ptr、weak_ptr
unique_ptr
立即学习“C++免费学习笔记（深入）”；
unique_ptr是独占式指针，意味着同一时间只能有一个unique_ptr指向特定的对象。它非常轻量级，开销几乎与原始指针相同，而且保证了对象所有权的唯一性。
#include <iostream> #include <memory> class MyClass { public: MyClass() { std::cout << "MyClass constructedn"; } ~MyClass() { std::cout << "MyClass destructedn"; } void doSomething() { std::cout << "Doing something...n"; } }; int main() { std::unique_ptr<MyClass> ptr(new MyClass()); // 创建 unique_ptr ptr->doSomething(); // 使用 -> 访问对象成员 // std::unique_ptr<MyClass> ptr2 = ptr; // 错误！不能复制 unique_ptr std::unique_ptr<MyClass> ptr2 = std::move(ptr); // 正确，转移所有权 if (ptr) { ptr->doSomething(); // 不会执行，因为 ptr 已经为空 } if (ptr2) { ptr2->doSomething(); // ptr2 现在拥有对象 } return 0; // ptr2 析构，MyClass 对象被销毁 }
unique_ptr的主要用途：
- 资源管理： 确保动态分配的对象在不再需要时被自动释放。
- 所有权转移： 通过std::move显式地转移所有权。
- 工厂函数： 用于从工厂函数返回动态分配的对象。
shared_ptr
shared_ptr允许多个指针指向同一个对象，它使用引用计数来跟踪有多少个shared_ptr指向该对象。当最后一个shared_ptr被销毁时，对象才会被释放。
#include <iostream> #include <memory> class MyClass { public: MyClass() { std::cout << "MyClass constructedn"; } ~MyClass() { std::cout << "MyClass destructedn"; } void doSomething() { std::cout << "Doing something...n"; } }; int main() { std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>(); // 推荐使用 make_shared std::shared_ptr<MyClass> ptr2 = ptr1; // 共享所有权 std::cout << "ptr1 use count: " << ptr1.use_count() << std::endl; // 输出 2 std::cout << "ptr2 use count: " << ptr2.use_count() << std::endl; // 输出 2 ptr1->doSomething(); ptr2->doSomething(); ptr1.reset(); // 释放 ptr1 的所有权 std::cout << "ptr1 use count: " << ptr1.use_count() << std::endl; // 输出 0 std::cout << "ptr2 use count: " << ptr2.use_count() << std::endl; // 输出 1 return 0; // ptr2 析构，MyClass 对象被销毁 }
shared_ptr的主要用途：
- 共享所有权： 当多个对象需要共享对一个资源的所有权时。
- 循环引用处理： 与weak_ptr结合使用，打破循环引用。
- 并发编程： 在多线程环境中安全地共享资源。
weak_ptr
weak_ptr是一种弱引用，它指向由shared_ptr管理的对象，但不增加引用计数。weak_ptr不能直接访问对象，必须先转换为shared_ptr才能使用。当shared_ptr管理的对象被销毁时，weak_ptr会自动失效。
#include <iostream> #include <memory> class MyClass { public: MyClass() { std::cout << "MyClass constructedn"; } ~MyClass() { std::cout << "MyClass destructedn"; } void doSomething() { std::cout << "Doing something...n"; } }; int main() { std::shared_ptr<MyClass> sharedPtr = std::make_shared<MyClass>(); std::weak_ptr<MyClass> weakPtr = sharedPtr; if (auto ptr = weakPtr.lock()) { // 尝试获取 shared_ptr ptr->doSomething(); // 安全地访问对象 std::cout << "Object is still aliven"; } else { std::cout << "Object has been destroyedn"; } sharedPtr.reset(); // 释放 shared_ptr 的所有权 if (auto ptr = weakPtr.lock()) { ptr->doSomething(); // 不会执行 std::cout << "Object is still aliven"; } else { std::cout << "Object has been destroyedn"; // 输出此行 } return 0; }
weak_ptr的主要用途：
- 观察者模式： 允许观察对象的状态，而不会影响对象的生命周期。
- 缓存： 缓存对象，当对象不再被使用时自动释放。
- 打破循环引用： 解决shared_ptr可能导致的循环引用问题。
如何选择合适的智能指针？
在选择智能指针时，需要考虑以下因素：
- 所有权模型： 是否需要独占所有权还是共享所有权？
- 性能： unique_ptr开销最小，shared_ptr开销较大。
- 线程安全： shared_ptr是线程安全的，unique_ptr不是。
- 循环引用： 是否需要处理循环引用问题？
为什么推荐使用make_shared？
std::make_shared是一个模板函数，用于创建一个shared_ptr并初始化其指向的对象。与先new再用shared_ptr包装相比，make_shared的主要优势在于：
- 异常安全： 如果new操作成功，但在shared_ptr构造函数中抛出异常，会导致内存泄漏。make_shared将对象的内存分配和shared_ptr的构造放在一起，避免了这个问题。
- 性能优化： make_shared通常会一次性分配对象和shared_ptr控制块的内存，减少内存分配次数，提高性能。
智能指针与原始指针的混合使用问题
虽然智能指针旨在替代原始指针，但在某些情况下，仍然需要与原始指针交互，例如：
- 与旧代码库集成： 旧代码库可能使用原始指针，需要将智能指针转换为原始指针进行交互。
- 底层操作： 某些底层操作可能需要直接访问内存地址。
在与原始指针交互时，需要格外小心，避免出现以下问题：
- 重复释放： 不要使用原始指针delete由智能指针管理的对象。
- 悬挂指针： 当智能指针释放对象后，原始指针可能变成悬挂指针。
可以使用get()方法从智能指针获取原始指针，但必须谨慎使用，并确保在使用原始指针时，智能指针仍然有效。
如何避免循环引用？
循环引用是指两个或多个对象相互持有shared_ptr，导致引用计数永远不为零，对象无法被释放。
例如：
#include <iostream> #include <memory> class A; // 前向声明 class B { public: std::shared_ptr<A> a; ~B() { std::cout << "B destructedn"; } }; class A { public: std::shared_ptr<B> b; ~A() { std::cout << "A destructedn"; } }; int main() { std::shared_ptr<A> a = std::make_shared<A>(); std::shared_ptr<B> b = std::make_shared<B>(); a->b = b; b->a = a; // 循环引用 // a 和 b 都不会被销毁，导致内存泄漏 return 0; }
解决循环引用的常用方法是使用weak_ptr。将其中一个shared_ptr改为weak_ptr，打破循环引用。
#include <iostream> #include <memory> class A; // 前向声明 class B { public: std::weak_ptr<A> a; // 使用 weak_ptr ~B() { std::cout << "B destructedn"; } }; class A { public: std::shared_ptr<B> b; ~A() { std::cout << "A destructedn"; } }; int main() { std::shared_ptr<A> a = std::make_shared<A>(); std::shared_ptr<B> b = std::make_shared<B>(); a->b = b; b->a = a; // 循环引用被打破 // a 和 b 都会被销毁 return 0; }
智能指针在多线程环境下的使用
shared_ptr本身是线程安全的，多个线程可以同时访问和修改同一个shared_ptr对象，而不会导致数据竞争。但是，shared_ptr指向的对象本身并不一定是线程安全的，需要额外的同步机制来保护对象的访问。
unique_ptr不是线程安全的，不应该在多个线程之间共享。如果需要在多线程之间传递所有权，可以使用std::move显式地转移所有权。
weak_ptr本身也是线程安全的，但需要注意，在将weak_ptr转换为shared_ptr时，可能会出现竞争条件。
自定义删除器
智能指针允许使用自定义删除器，用于在对象被销毁时执行特定的操作。自定义删除器可以是一个函数、函数对象或Lambda表达式。
#include <iostream> #include <memory> void customDeleter(int* ptr) { std::cout << "Custom deleter calledn"; delete ptr; } int main() { std::unique_ptr<int, void(*)(int*)> ptr(new int(10), customDeleter); // 或者使用 lambda 表达式 std::shared_ptr<int> sharedPtr(new int(20), [](int* ptr) { std::cout << "Lambda deleter calledn"; delete ptr; }); return 0; }
自定义删除器的主要用途：
- 释放非内存资源： 例如文件句柄、网络连接等。
- 执行特定的清理操作： 例如关闭数据库连接、释放锁等。
- 与C风格API集成： 当需要使用C风格的释放函数时。
智能指针的性能考量
虽然智能指针提供了很多便利，但也带来了一些性能开销：
- 引用计数： shared_ptr需要维护引用计数，增加了一些额外的开销。
- 虚函数表： 如果使用自定义删除器，可能会增加虚函数表的开销。
- 内存分配： shared_ptr的控制块和对象可能需要分别分配内存。
在性能敏感的场景下，需要仔细评估智能指针的性能影响，并选择合适的智能指针类型。在不需要共享所有权的情况下，优先使用unique_ptr。
总结
C++智能指针是管理动态内存的强大工具，可以有效地避免内存泄漏和悬挂指针。理解不同类型的智能指针的特点和适用场景，可以编写更安全、更可靠的C++代码。记住，选择合适的智能指针是关键，并且需要谨慎处理与原始指针的交互，以避免潜在的问题。
