智能指针通过自动内存管理解决c++中手动管理内存导致的泄漏问题。1. unique_ptr实现独占所有权，不可复制但可移动，适合单一所有者场景；2. shared_ptr采用引用计数实现共享所有权，适用于多指针共享对象的情况，但需注意循环引用问题；3. weak_ptr作为弱引用不增加引用计数，用于打破shared_ptr之间的循环引用。此外，推荐使用make_unique和make_shared创建智能指针，以提高性能和异常安全性，同时避免与原始指针混合使用带来的双重释放、内存泄漏和悬挂指针等风险。
智能指针本质上是为了更好地管理C++中的内存，避免手动new和delete带来的内存泄漏问题。它们就像负责任的保姆，在你不再需要某个对象时自动释放它，让你从繁琐的内存管理中解放出来。
解决方案
C++提供了三种主要的智能指针：unique_ptr、shared_ptr和weak_ptr。选择哪种取决于你的具体需求和对象的所有权模型。
立即学习“C++免费学习笔记（深入）”；
-
unique_ptr：独占所有权
unique_ptr代表独占所有权，也就是说，同一时间只能有一个unique_ptr指向某个对象。当unique_ptr销毁时，它所指向的对象也会被自动删除。这使得unique_ptr非常适合用于管理那些只需要单个所有者的情况，比如函数内部创建的对象。#include <iostream> #include <memory> class MyClass { public: MyClass() { std::cout << "MyClass created\n"; } ~MyClass() { std::cout << "MyClass destroyed\n"; } }; int main() { std::unique_ptr<MyClass> ptr(new MyClass()); // 或者使用 make_unique (C++14及以上) // auto ptr = std::make_unique<MyClass>(); if (ptr) { std::cout << "unique_ptr is not null\n"; } // 当ptr离开作用域时，MyClass对象会被自动销毁 return 0; }关键点：
unique_ptr不能复制，但可以移动（使用std::move）。这意味着你可以将所有权从一个unique_ptr转移到另一个。 -
shared_ptr：共享所有权shared_ptr允许多个智能指针指向同一个对象，它使用引用计数来跟踪有多少个shared_ptr指向该对象。当最后一个shared_ptr销毁时，对象才会被删除。这对于需要在多个地方共享对象所有权的情况非常有用。#include <iostream> #include <memory> class MyClass { public: MyClass() { std::cout << "MyClass created\n"; } ~MyClass() { std::cout << "MyClass destroyed\n"; } }; int main() { std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>(); std::shared_ptr<MyClass> ptr2 = ptr1; // ptr1和ptr2共享同一个对象 std::cout << "Reference count: " << ptr1.use_count() << "\n"; // 输出 2 ptr1.reset(); // ptr1不再指向对象，引用计数减1 std::cout << "Reference count: " << ptr2.use_count() << "\n"; // 输出 1 // 当ptr2离开作用域时，MyClass对象会被自动销毁 return 0; }注意：
shared_ptr会带来一定的性能开销，因为需要维护引用计数。另外，循环引用会导致内存泄漏，需要使用weak_ptr来解决。 -
weak_ptr：观察者weak_ptr是一种弱引用，它指向由shared_ptr管理的对象，但不增加引用计数。weak_ptr可以用来检查对象是否仍然存在，并且可以从weak_ptr创建一个shared_ptr来获取对象的所有权（如果对象仍然存在）。这对于打破循环引用非常有用。#include <iostream> #include <memory> class B; // 前向声明 class A { public: std::shared_ptr<B> b_ptr; ~A() { std::cout << "A destroyed\n"; } }; class B { public: std::weak_ptr<A> a_ptr; // 使用 weak_ptr 打破循环引用 ~B() { std::cout << "B destroyed\n"; } }; int main() { 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; // 现在A和B相互引用 // 如果使用 shared_ptr<A> a_ptr; 在B中，则会造成内存泄漏 return 0; }在这个例子中，
B类中的a_ptr使用weak_ptr，避免了A和B之间的循环引用，从而防止了内存泄漏。
智能指针的优势
-
自动内存管理：避免手动
new和delete，减少内存泄漏的风险。 - 异常安全：即使在抛出异常的情况下，也能保证资源被正确释放。
- 代码简洁：减少了手动内存管理的代码，使代码更易读、易维护。
智能指针并非银弹，选择合适的智能指针类型，并理解其背后的所有权模型，才能真正发挥其优势。
make_unique 和 make_shared 的区别和选择
make_unique (C++14引入) 和 make_shared 都是创建智能指针的推荐方式，但它们之间存在一些关键区别，影响着你的选择。
make_unique: 专门用于创建unique_ptr。它直接在一次内存分配中创建对象和unique_ptr的控制块（如果存在）。这通常更高效，并且提供了更强的异常安全性。make_shared: 用于创建shared_ptr。它也尝试在一次内存分配中创建对象和shared_ptr的控制块（包含引用计数等信息）。然而，make_shared只能访问对象的公共构造函数。
选择的关键因素：
-
性能:
make_shared在某些情况下可能比单独的new和shared_ptr构造函数更高效，因为它减少了内存分配的次数。但是，如果对象很大，且频繁分配和释放，这种优势可能会减弱。 -
异常安全性: 使用
make_unique和make_shared可以提供更强的异常安全性，避免在new操作和shared_ptr构造函数之间抛出异常导致内存泄漏。 -
访问权限:
make_shared只能访问对象的公共构造函数。如果你的对象只有私有或受保护的构造函数，则不能使用make_shared。 -
自定义删除器: 如果你需要使用自定义删除器，
make_unique和make_shared的用法略有不同，但都支持。
总的来说，尽可能使用 make_unique 和 make_shared，除非你有特殊的需求（例如，需要访问私有构造函数或使用自定义删除器）。
如何处理循环引用导致的内存泄漏？
循环引用是使用 shared_ptr 时需要特别注意的问题。当两个或多个对象相互持有对方的 shared_ptr 时，它们的引用计数永远不会降为零，导致对象永远不会被释放，从而造成内存泄漏。
解决方案：weak_ptr
weak_ptr 是解决循环引用的关键。weak_ptr 是一种弱引用，它指向由 shared_ptr 管理的对象，但不增加引用计数。你可以使用 weak_ptr 来打破循环引用。
示例：
#include <iostream>
#include <memory>
class B; // 前向声明
class A {
public:
std::shared_ptr<B> b_ptr;
~A() { std::cout << "A destroyed\n"; }
};
class B {
public:
std::weak_ptr<A> a_ptr; // 使用 weak_ptr 打破循环引用
~B() { std::cout << "B destroyed\n"; }
};
int main() {
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; // 现在A和B相互引用
// 如果使用 shared_ptr<A> a_ptr; 在B中，则会造成内存泄漏
return 0;
}在这个例子中，B类中的a_ptr使用weak_ptr，避免了A和B之间的循环引用，从而防止了内存泄漏。
使用 weak_ptr 的注意事项：
- 在使用
weak_ptr访问对象之前，需要先检查对象是否仍然存在。可以使用weak_ptr::lock()方法创建一个shared_ptr，如果对象已经被销毁，则返回空的shared_ptr。 -
weak_ptr不拥有对象的所有权，因此不能直接通过weak_ptr修改对象。
智能指针与原始指针的混合使用：风险与防范
虽然智能指针旨在取代原始指针，但在某些情况下，你可能仍然需要与原始指针交互。这种混合使用带来了风险，需要谨慎处理。
常见风险：
- 双重释放: 多个智能指针或智能指针与原始指针同时管理同一块内存，可能导致重复释放。
- 内存泄漏: 忘记释放原始指针指向的内存，或者智能指针超出作用域但原始指针仍然持有该内存的引用，都可能导致内存泄漏。
- 悬挂指针: 原始指针指向的内存已经被智能指针释放，导致原始指针变成悬挂指针。
防范措施：
- 避免混合使用: 尽可能避免智能指针和原始指针同时管理同一块内存。
- 明确所有权: 明确哪个智能指针拥有对象的唯一所有权。
-
谨慎使用
get()方法:shared_ptr::get()方法返回原始指针，但使用时需要非常小心，确保不会导致双重释放或内存泄漏。 -
使用
release()方法:unique_ptr::release()方法释放unique_ptr对对象的所有权，并返回原始指针。使用后需要手动释放该指针指向的内存。 - 遵循 RAII 原则: 确保资源在对象构造时获取，在对象析构时释放。
示例：避免双重释放
#include <iostream>
#include <memory>
int main() {
int* raw_ptr = new int(10);
std::shared_ptr<int> shared_ptr1(raw_ptr);
// 错误的做法：不要用同一个原始指针创建多个智能指针
// std::shared_ptr<int> shared_ptr2(raw_ptr); // 错误！会导致双重释放
// 正确的做法：使用 shared_ptr1
std::cout << *shared_ptr1 << std::endl;
return 0;
}在这个例子中，使用同一个原始指针创建了两个 shared_ptr，当这两个 shared_ptr 超出作用域时，会尝试释放同一块内存两次，导致程序崩溃。
总而言之，虽然智能指针极大地简化了内存管理，但在与原始指针交互时，仍然需要保持警惕，避免潜在的风险。
