C++中，智能指针的生命周期-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_57269946/article/details/145853669

一、智能指针的生命周期核心机制

1. std::unique_ptr（独占所有权）

2. std::shared_ptr（共享所有权）

3. std::weak_ptr（弱引用观察者）

1. 循环引用（shared_ptr特有）

场景1：动态数组管理（unique_ptr）

场景2：多对象共享配置（shared_ptr）

一、智能指针的生命周期核心机制

智能指针通过 RAII（资源获取即初始化） 自动管理动态分配的内存，生命周期与对象的作用域紧密绑定。以下是三类智能指针的核心特点：

1. `std::unique_ptr`（独占所有权）

生命周期规则：
- 资源的所有权唯一，只能通过移动（std::move）转移所有权。
- 当unique_ptr离开作用域时，自动释放其管理的资源。

示例：

Cpp
{
    std::unique_ptr<int> uptr = std::make_unique<int>(42);  // 分配内存
    // uptr 作用域内有效
} // 离开作用域时自动释放内存

2. `std::shared_ptr`（共享所有权）

生命周期规则：
- 多个shared_ptr实例共享资源所有权，通过引用计数管理生命周期。
- 当最后一个shared_ptr离开作用域或重置时，引用计数归零，资源被释放。

示例：

Cpp
{
    auto sptr1 = std::make_shared<int>(100);  // 引用计数=1
    {
        auto sptr2 = sptr1;  // 引用计数=2
    } // sptr2 销毁，引用计数=1
} // sptr1 销毁，引用计数=0，内存释放

内存模型：每个shared_ptr包含两个指针，分别指向资源和控制块（含引用计数）。

3. std::weak_ptr（弱引用观察者）
生命周期规则：
- 不增加引用计数，仅观察资源是否存在。
- 必须通过lock()转换为shared_ptr才能访问资源，若资源已释放则返回空指针。

示例：

Cpp
std::weak_ptr<int> wptr;
{
    auto sptr = std::make_shared<int>(200);
    wptr = sptr;  // 弱引用，引用计数仍为1
} // sptr 销毁，引用计数归零，内存释放
if (auto temp = wptr.lock()) {  // 资源已释放，temp为空
    // 不会执行
}

二、生命周期管理的关键操作

1. 所有权转移

unique_ptr通过移动转移所有权：

Cpp
auto uptr1 = std::make_unique<int>(10);
auto uptr2 = std::move(uptr1);  // uptr1变为nullptr

shared_ptr通过赋值共享所有权：

Cpp
auto sptr1 = std::make_shared<int>(20);
auto sptr2 = sptr1;  // 引用计数+1

2. 显式释放资源

reset()方法：

Cpp
sptr1.reset();  // 手动释放资源，引用计数-1

3. 自定义删除器

适用场景：管理非内存资源（如文件句柄、网络连接）。

示例：

Cpp
// 自定义文件关闭逻辑
auto file_deleter = [](FILE* fp) { if (fp) fclose(fp); };
std::unique_ptr<FILE, decltype(file_deleter)> uptr(fopen("test.txt", "r"), file_deleter);

三、生命周期管理的陷阱与解决方案

1. 循环引用（`shared_ptr`特有）

问题：两个对象互相持有对方的shared_ptr，导致引用计数无法归零。

解决：将其中一个指针改为weak_ptr。

class B; // 前置声明
class A {
public:
    std::shared_ptr<B> b_ptr;
};
class B {
public:
    std::weak_ptr<A> a_weak;  // 使用弱引用打破循环
};

2. 裸指针误用

避免操作get()返回的裸指针：

auto sptr = std::make_shared<int>(30);
int* raw = sptr.get();
delete raw;  // 错误！会导致双重释放

3. 性能优化

优先使用std::make_shared/std::make_unique：
- 减少内存分配次数（控制块与对象内存合并）。
- 提高异常安全性（避免构造函数异常导致内存泄漏）。

四、生命周期管理的最佳实践

优先选择unique_ptr：若不需要共享所有权，避免shared_ptr的引用计数开销。
慎用weak_ptr的lock()：检查返回的shared_ptr是否有效后再使用。
避免在容器中混合智能指针与裸指针：防止生命周期管理混乱。
跨线程共享时使用shared_ptr：确保线程安全（需结合互斥锁等机制）。

五、示例场景

场景1：动态数组管理（`unique_ptr`）

{
    std::unique_ptr<int[]> arr = std::make_unique<int[]>(5);
    for (int i = 0; i < 5; ++i) arr[i] = i;
} // 数组自动释放

场景2：多对象共享配置（`shared_ptr`）

struct Config { /* 配置参数 */ };
auto config = std::make_shared<Config>();
auto worker1 = std::make_shared<Worker>(config);
auto worker2 = std::make_shared<Worker>(config);  // 共享配置

通过上述机制和操作，智能指针能够有效管理内存生命周期，避免常见的内存泄漏和悬垂指针问题。