智能指针
智能指针是C++提供的一种资源管理工具，用于自动管理动态分配的内存，避免手动调用 new 和 delete 时可能出现的内存泄漏、悬挂指针等问题。智能指针通过封装原始指针，并在适当的时候自动释放资源，从而简化了内存管理。
智能指针在C++11版本之后提供，包含在头文件<memory>中，主要包括以下几种shared_ptr、unique_ptr、weak_ptr：
std::unique_ptr
独占所有权的智能指针
每个 unique_ptr 对象只能拥有一个指向的对象，不能复制，但可以转移所有权。
std::shared_ptr
共享所有权的智能指针
多个 shared_ptr 可以同时指向同一个对象，当最后一个 shared_ptr 被销毁或重置时，才会释放所指向的对象。
std::weak_ptr
弱引用智能指针
配合shared_ptr引入的一种智能指针，它不增加引用计数，主要用于解决 shared_ptr 之间的循环引用问题。
简述
- unique_ptr：独占式指针，同一时刻只能有一个指针指向同一个对象
- shared_ptr：共享式指针，同一时刻可以有多个指针指向同一个对象
- weak_ptr：用来解决shared_ptr相互引用导致的死锁问题
理解
- 智能指针利用了RAII（Resource Acquisition Is Initializatio 资源获取即初始化）
对普通的指针进行封装，这使得智能指针实质是一个对象，行为表现的却像一个指针- 智能指针防止
①忘记调用delete释放内存
②程序异常的进入catch块忘记释放内存
③多次释放同一个指针(会造成程序崩溃)- 智能指针把值语义转换成引用语义
实现原理
1. std::unique_ptr 的实现原理
std::unique_ptr 是最简单的智能指针，它的实现基于 RAII（Resource Acquisition Is Initialization）原则。unique_ptr 在构造时获取资源，在析构时自动释放资源。由于它是独占所有权的，因此不允许复制，但可以通过 std::move 来转移所有权。
2. std::shared_ptr 的实现原理
std::shared_ptr 通过引用计数机制来管理对象的生命周期。多个 shared_ptr 可以共享同一个对象，只有当所有共享该对象的 shared_ptr 都被销毁或重置时，才会释放该对象。
引用计数：shared_ptr 内部维护一个控制块（control block），其中包含两个计数器：
强引用计数：记录有多少个 shared_ptr 正在共享该对象。当强引用计数为 0 时，对象会被销毁。
弱引用计数：记录有多少个 weak_ptr 正在引用该对象。弱引用计数用于管理控制块的生命周期，当弱引用计数也为 0 时，控制块也会被释放。
线程安全：shared_ptr 的引用计数操作是线程安全的，即多个线程可以同时对同一个 shared_ptr 进行增减引用计数，而不会导致竞争条件。
3. std::weak_ptr 的实现原理
std::weak_ptr 是 shared_ptr 的一种弱引用形式，它不增加强引用计数，因此不会影响对象的生命周期。weak_ptr 主要用于解决 shared_ptr 之间的循环引用问题。
弱引用：weak_ptr 不直接持有对象的所有权，它只是通过 shared_ptr 的控制块来访问对象。如果对象已经被销毁，weak_ptr 会感知到这一点，并返回一个空的 shared_ptr。
锁机制：通过 lock() 方法，weak_ptr 可以临时获得一个 shared_ptr，从而安全地访问对象。如果对象已经被销毁，lock() 会返回一个空的 shared_ptr。
代码示例
#include <iostream>
#include <memory> // 引入智能指针的头文件
// 定义一个简单的类
class Resource {
public:
Resource() { std::cout << "Resource created\n"; }
~Resource() { std::cout << "Resource destroyed\n"; }
void doSomething() const {
std::cout << "Doing something...\n";
}
};
int main() {
// === 使用 unique_ptr ===
{
// 创建一个 unique_ptr，独占所有权
std::unique_ptr<Resource> uniquePtr = std::make_unique<Resource>();
// 调用对象的方法
uniquePtr->doSomething();
// 尝试复制 unique_ptr（编译错误）
// std::unique_ptr<Resource> anotherUniquePtr = uniquePtr;
// 移动所有权
std::unique_ptr<Resource> movedUniquePtr = std::move(uniquePtr);
// uniquePtr 现在为空，无法再访问资源
if (!uniquePtr) {
std::cout << "uniquePtr is now empty\n";
}
// movedUniquePtr 仍然持有资源
movedUniquePtr->doSomething();
} // 当作用域结束时，movedUniquePtr 自动释放资源
std::cout << "After unique_ptr scope\n";
// === 使用 shared_ptr ===
{
// 创建一个 shared_ptr，共享所有权
std::shared_ptr<Resource> sharedPtr1 = std::make_shared<Resource>();
// 获取引用计数
std::cout << "Reference count: " << sharedPtr1.use_count() << "\n";
// 创建另一个 shared_ptr，共享同一个对象
std::shared_ptr<Resource> sharedPtr2 = sharedPtr1;
std::cout << "Reference count after copying: " << sharedPtr1.use_count() << "\n";
// 调用对象的方法
sharedPtr1->doSomething();
// 当 sharedPtr2 超出作用域时，引用计数减1
} // sharedPtr2 超出作用域，引用计数变为1
// sharedPtr1 仍然存在，对象不会被销毁
std::cout << "After shared_ptr2 scope\n";
// === 使用 weak_ptr ===
{
// 创建一个 shared_ptr，用于创建 weak_ptr
std::shared_ptr<Resource> sharedPtr3 = std::make_shared<Resource>();
// 创建一个 weak_ptr，弱引用 sharedPtr3 所指向的对象
std::weak_ptr<Resource> weakPtr = sharedPtr3;
// 检查 weak_ptr 是否仍然有效
if (auto lockedPtr = weakPtr.lock()) {
// 如果对象仍然存在，lockedPtr 是一个有效的 shared_ptr
std::cout << "Object is still alive\n";
lockedPtr->doSomething();
} else {
// 对象已被销毁
std::cout << "Object has been destroyed\n";
}
// 释放 sharedPtr3，对象将被销毁
sharedPtr3.reset();
// 再次检查 weak_ptr
if (auto lockedPtr = weakPtr.lock()) {
// 对象已被销毁，lockedPtr 为空
std::cout << "Object is still alive\n";
} else {
std::cout << "Object has been destroyed\n";
}
}
return 0;
}代码输出
Resource created
Doing something...
uniquePtr is now empty
Doing something...
Resource destroyed
After unique_ptr scope
Resource created
Reference count: 1
Reference count after copying: 2
Doing something...
Resource destroyed
After shared_ptr2 scope
Resource created
Object is still alive
Doing something...
Resource destroyed
Object has been destroyed智能指针是C++中非常重要的工具，能够有效管理动态分配的内存，避免常见的内存管理问题。std::unique_ptr 适用于独占所有权的场景，std::shared_ptr 适用于共享所有权的场景，而 std::weak_ptr 则用于解决循环引用问题。
