C++ 智能指针完全指南：从原理到实战，彻底告别内存泄漏
（基于 C++11/14/17/20/23 现代实践，2025–2026 年主流写法）

智能指针是现代 C++ RAII（资源获取即初始化）的核心武器，几乎彻底取代了手动 new/delete。用对它们，内存泄漏、悬垂指针、double delete 等经典 bug 会大幅减少。

一、三大智能指针对比（2026 年最实用速查表）

2026 年铁律：优先 unique_ptr > shared_ptr（谨慎） > raw pointer（只借用）
永远不要：在拥有资源的类成员中用 raw pointer（除非明确生命周期更短）。

二、核心原理（一句话总结每个）

1. unique_ptr：独占所有权 + move-only
   → 析构时自动 delete，禁止拷贝（只能 move 转移所有权）

2. shared_ptr：引用计数 + 控制块（control block）
   → 强引用计数 = 0 时 delete 对象
   → 控制块通常包含：强计数、弱计数、deleter、allocator

3. weak_ptr：不增加强引用，只观察
   → lock() → shared_ptr（计数+1）或空（对象已亡）
   → 解决 shared_ptr 最致命问题：循环引用导致泄漏

三、创建方式对比（性能 & 安全第一）

经验法则：

• 99% 的 new T 都应该写成 make_unique / make_shared
• 只有自定义 deleter / allocator 时才手动 new + 传给构造函数

四、实战代码模式（最常见场景）

1. 函数返回动态对象（工厂模式）

// 最佳写法（C++14+）
auto create_widget(int id) -> std::unique_ptr<Widget> {
    return std::make_unique<Widget>(id);
}

// 或用 make_unique_for_overwrite (C++20，当不需初始化时)
auto buf = std::make_unique_for_overwrite<char[]>(size);

2. 类成员拥有资源（PIMPL / 策略模式）

class Renderer {
    struct Impl;                    // 前向声明
    std::unique_ptr<Impl> pImpl_;  // 独占实现

public:
    Renderer();
    ~Renderer() = default;         // unique_ptr 自动析构
    // move-only 或 =default 特殊成员
};

3. 共享资源 + 避免循环引用

class Node {
public:
    std::shared_ptr<Node> parent;
    std::weak_ptr<Node>   first_child;   // 弱引用，避免循环

    ~Node() { std::cout << "Node destroyed\n"; }
};

void test_cycle() {
    auto parent = std::make_shared<Node>();
    auto child  = std::make_shared<Node>();
    
    parent->first_child = child;           // weak ← 不增计数
    child->parent       = parent;          // shared ← 增计数

    // parent 析构时 child 引用计数变为1 → 正常析构
}

4. 缓存 / 观察者模式（weak + lock）

class Cache {
    std::unordered_map<Key, std::weak_ptr<Value>> cache_;

public:
    std::shared_ptr<Value> get(const Key& k) {
        if (auto it = cache_.find(k); it != cache_.end()) {
            if (auto sp = it->second.lock()) {   // 尝试提升
                return sp;
            }
            cache_.erase(it);   // 已过期，清理
        }
        // miss → 创建并存弱引用
        auto val = std::make_shared<Value>(...);
        cache_[k] = val;
        return val;
    }
};

五、2025–2026 年最值得关注的现代最佳实践

1. 参数传递规则（C++ Core Guidelines R.30–R.37 精华）

   • 要借用 → T* / T& / const T&
   • 要可空借用 → T*（nullptr 表示无）
   • 要转移所有权 → unique_ptr<T>&& 或直接返回 unique_ptr
   • 要共享所有权 → const shared_ptr<T>&（只读）或 shared_ptr<T>（可能 copy）
   • 绝不要 shared_ptr<T>&（非 const）作为参数，除非明确要修改控制块

2. 启用 /disable ADL 陷阱

   • 不要在 std 里放东西
   • using std::swap; 是安全的（C++20 前常见写法）

3. 自定义 deleter（文件、socket 等资源）

auto file = std::unique_ptr<FILE, decltype(&fclose)>{
    fopen("data.txt", "r"), fclose};

4. 启用 sanitizers（日常开发必备）

   • -fsanitize=address,undefined,leak
   • 配合 CI 跑，基本能抓住 95% 的剩余内存问题

5. C++20/23 新工具（辅助智能指针）

   • std::enable_shared_from_this（仍有用，但优先避免）
   • std::out_ptr / std::inout_ptr（C++23，与 C API 交互更安全）

一句话总结现代 C++ 内存管理心态：

“能用值/栈就用值，能用 unique 就用 unique，需要共享才用 shared，用 shared 就要想到 weak”

你现在最常遇到哪类问题？

• unique_ptr vs shared_ptr 选择困难？
• 循环引用怎么 debug？
• 老代码改造（从 raw → smart）策略？
• 多线程下 shared_ptr 性能瓶颈？
• 自定义 deleter / array 特殊情况？

告诉我具体场景或代码片段，我可以帮你分析 / 改写成最安全的现代写法。