C++中智能指针的生命周期管理技巧

在现代C++开发中，智能指针（std::unique_ptr、std::shared_ptr、std::weak_ptr）已成为管理动态资源的首选工具。它们通过 RAII（资源获取即初始化）模式，确保资源在离开作用域时自动释放，显著减少了内存泄漏和悬挂指针的风险。然而，智能指针的生命周期管理仍然存在细微的陷阱和优化空间。本文将从常见使用场景、生命周期细节、以及高级技巧三方面，深入剖析如何有效利用智能指针实现安全、高效的资源管理。

1. 基础概念回顾

1.1 `unique_ptr`

唯一所有权：同一时刻只能有一个 unique_ptr 拥有某个对象。适用于不需要共享的场景。
移动语义：通过 std::move 传递所有权，避免不必要的拷贝。

std::unique_ptr <MyClass> ptr1(new MyClass);
std::unique_ptr <MyClass> ptr2 = std::move(ptr1); // ptr1 变为空指针

1.2 `shared_ptr`

共享所有权：内部维护引用计数。最后一个 shared_ptr 被销毁时，所指对象才被删除。
多线程安全：引用计数操作是原子性的，但对象内部状态仍需手动同步。

std::shared_ptr <MyClass> ptr1(new MyClass);
std::shared_ptr <MyClass> ptr2 = ptr1; // 引用计数 +1

1.3 `weak_ptr`

弱引用：不增加引用计数，解决 shared_ptr 循环引用问题。
转换为 shared_ptr：通过 lock() 检查对象是否存活。

std::weak_ptr <MyClass> weak = ptr1;
if (auto shared = weak.lock()) {
    // 对象存活
}

2. 生命周期细节与常见陷阱

2.1 循环引用的危害

在双向关联（如图形节点、父子关系）中，若双方使用 shared_ptr，会产生循环引用，导致引用计数永不归零，造成内存泄漏。典型做法是：

使用 weak_ptr：一方持有 weak_ptr，另一方持有 shared_ptr。例如，子节点指向父节点时使用 weak_ptr。

class Node {
public:
    std::shared_ptr <Node> parent;
    std::vector<std::shared_ptr<Node>> children;
};

改为：

class Node {
public:
    std::weak_ptr <Node> parent;          // 弱引用
    std::vector<std::shared_ptr<Node>> children; // 强引用
};

2.2 共享指针的异常安全

shared_ptr 的引用计数是原子操作，但在异常抛出时，必须确保计数的一致性。例如，使用 std::make_shared 可以一次性完成内存分配和计数初始化，避免中途抛异常导致计数不完整。

// 推荐
auto ptr = std::make_shared <MyClass>(arg1, arg2);

// 低效且易错
std::shared_ptr <MyClass> ptr(new MyClass(arg1, arg2));

2.3 `unique_ptr` 与 `array`

标准库不提供 unique_ptr<T[]> 的析构函数默认调用 delete[]，因此需要显式指定 deleter 或使用 std::make_unique<T[]>(size)（C++14 之后）：

auto arr = std::make_unique<int[]>(10); // 10 个 int

3. 高级技巧：自定义 deleter、回调机制与资源池

3.1 自定义 deleter

在某些场景下，资源释放方式与标准 delete 不同（如使用 free、文件句柄、网络连接）。可以为 unique_ptr 或 shared_ptr 指定自定义 deleter。

struct FileDeleter {
    void operator()(FILE* fp) const {
        if (fp) fclose(fp);
    }
};

std::unique_ptr<FILE, FileDeleter> filePtr(fopen("log.txt", "r"));

自定义 deleter 还可以捕获外部上下文，例如：

auto logger = std::make_shared <Logger>();
auto deleter = [logger](MyClass* ptr) {
    logger->log("Deleting MyClass");
    delete ptr;
};
std::unique_ptr<MyClass, decltype(deleter)> ptr(new MyClass, deleter);

3.2 回调机制：让资源自动回收

在大型项目中，往往需要在资源释放前触发回调，例如释放 GPU 缓冲区时需要先同步。可以结合 std::function 与自定义 deleter。

auto deleter = [](GpuBuffer* buf) {
    buf->synchronize();
    delete buf;
};

std::unique_ptr<GpuBuffer, decltype(deleter)> gpuBuf(new GpuBuffer, deleter);

3.3 资源池与智能指针

对于频繁分配/释放的对象（如线程池中的任务对象），创建对象池可以显著降低堆内存碎片。结合智能指针可以实现安全的对象回收。

class ObjectPool {
public:
    std::shared_ptr <MyObject> acquire() {
        std::lock_guard<std::mutex> lock(mutex_);
        if (!pool_.empty()) {
            auto obj = pool_.back();
            pool_.pop_back();
            return obj;
        } else {
            return std::make_shared <MyObject>();
        }
    }

    void release(std::shared_ptr <MyObject> obj) {
        std::lock_guard<std::mutex> lock(mutex_);
        pool_.push_back(obj);
    }

private:
    std::vector<std::shared_ptr<MyObject>> pool_;
    std::mutex mutex_;
};

在使用时：

auto obj = pool.acquire();
doSomething(obj);
// 自动返回池中
pool.release(obj);

4. 性能考量

4.1 `shared_ptr` 的复制成本

shared_ptr 复制时需要原子加减计数，虽然线程安全，但在单线程或高并发环境下会成为瓶颈。建议：

局部共享：仅在必要时传递 shared_ptr，尽量使用 const 或 weak_ptr。
std::move：传递所有权时使用 std::move，避免不必要的计数操作。

4.2 对齐与分配优化

std::make_shared 与 make_unique 通过单次分配同时创建对象和计数（对于 shared_ptr），减少堆碎片。对于自定义 allocator，使用 std::pmr::polymorphic_allocator 可以进一步优化。

auto buf = std::pmr::polymorphic_allocator <char>(pmr::unsynchronized_pool_resource{});
auto ptr = std::allocate_shared<std::string>(buf, "Hello");

5. 结语

智能指针已成为 C++ 稳定性和安全性的基石，但其生命周期管理仍需细致关注。通过正确使用 unique_ptr、shared_ptr 与 weak_ptr，结合自定义 deleter、回调与资源池模式，开发者可以在保持代码简洁的同时，获得高效、可靠的资源管理。未来 C++ 标准继续完善智能指针的特性（如 std::make_shared_for_overwrite 等），我们应紧跟其步伐，及时更新最佳实践。

1. 基础概念回顾

1.1 unique_ptr

1.2 shared_ptr

1.3 weak_ptr