智能指针 ⭐⭐⭐

void processData() {
    int* p = new int(42);       // 在堆上分配一个 int，值为 42
    // ... 中间有大量业务逻辑 ...
    doSomething(p);             // 如果此函数抛出异常呢？
    delete p;                   // 这一行可能永远不会被执行！
}

class AutoIntPtr {
private:
    int* raw_;                              // 内部持有的原始指针
 
public:
    explicit AutoIntPtr(int* p = nullptr)   // 构造时"获取"资源（接管指针所有权）
        : raw_(p) {}
 
    ~AutoIntPtr() {                         // 析构时"释放"资源
        delete raw_;                        // 自动调用 delete，无需手动操心
        raw_ = nullptr;                     // 置空，防止悬空（防御性编程）
    }
 
    int& operator*() const {                // 重载解引用运算符，模拟原始指针行为
        return *raw_;
    }
 
    int* operator->() const {               // 重载箭头运算符
        return raw_;
    }
 
    // 禁止拷贝（先简单处理，后面 unique_ptr 章节会深入讨论）
    AutoIntPtr(const AutoIntPtr&) = delete;             // 禁止拷贝构造
    AutoIntPtr& operator=(const AutoIntPtr&) = delete;  // 禁止拷贝赋值
};

void safeProcess() {
    AutoIntPtr p(new int(42));   // p 是栈对象，持有堆上的 int
    std::cout << *p << "\n";     // 像原始指针一样使用：输出 42
    // 不需要写 delete！
}   // <-- p 离开作用域，析构函数自动调用 delete

// ==================== unique_ptr 内存模型 ====================
//
//  栈 (Stack)                    堆 (Heap)
//  ┌────────────────┐           ┌──────────────┐
//  │ unique_ptr<Foo> │──────────▶│  Foo 对象     │
//  │  (仅一个指针)    │           │  data: 42    │
//  └────────────────┘           └──────────────┘
//      唯一拥有者                   被管理的资源
//
//
// ==================== shared_ptr 内存模型 ====================
//
//  栈 (Stack)                    堆 (Heap)
//  ┌────────────────┐
//  │ shared_ptr<Foo> │─────┐    ┌──────────────────┐
//  │  ptr + ctrl     │     ├───▶│  控制块 (Control  │
//  └────────────────┘     │    │   Block)          │
//  ┌────────────────┐     │    │  strong_count: 2  │
//  │ shared_ptr<Foo> │─────┘    │  weak_count:   1  │
//  │  ptr + ctrl     │         └──────────────────┘
//  └────────────────┘                  │
//  ┌────────────────┐                  ▼
//  │  weak_ptr<Foo>  │──────▶   ┌──────────────┐
//  │  ptr + ctrl     │          │  Foo 对象     │
//  └────────────────┘          │  data: 42    │
//                              └──────────────┘
//
//  两个 shared_ptr 共享同一个控制块和对象
//  weak_ptr 也指向控制块，但 不增加 strong_count

std::auto_ptr<int> a(new int(10));  // a 拥有这块内存
std::auto_ptr<int> b = a;           // b "拷贝" a —— 但实际上 a 被掏空了！
// 此时 a 为 nullptr，b 拥有内存
// 这违反了 "拷贝" 的基本语义：拷贝后原对象应该不变

void processData() {
    int* data = new int(42);       // 在堆上分配内存
 
    if (someCondition()) {
        return;                    // ⚠️ 提前返回，data 未被释放 → 内存泄漏!
    }
 
    doSomething(data);
 
    delete data;                   // 只有走到这里才能释放
}

#include <memory>                             // 智能指针头文件
 
void processData() {
    auto data = std::make_unique<int>(42);    // 创建 unique_ptr，自动管理内存
 
    if (someCondition()) {
        return;                               // ✅ 安全！data 离开作用域时自动释放
    }
 
    doSomething(data.get());                  // .get() 获取裸指针传给旧接口
}                                             // ✅ 函数结束，data 析构，内存自动释放

template <typename T>
class SimpleUniquePtr {
private:
    T* raw_ptr;                                // 内部持有一个裸指针
 
public:
    // 构造函数：接管裸指针的所有权
    explicit SimpleUniquePtr(T* p = nullptr)
        : raw_ptr(p) {}
 
    // 析构函数：释放所管理的内存（RAII 的核心）
    ~SimpleUniquePtr() {
        delete raw_ptr;                        // 离开作用域时自动 delete
    }
 
    // ========== 禁止拷贝（独占语义的关键）==========
    SimpleUniquePtr(const SimpleUniquePtr&) = delete;             // 拷贝构造 → 禁用
    SimpleUniquePtr& operator=(const SimpleUniquePtr&) = delete;  // 拷贝赋值 → 禁用
 
    // ========== 允许移动（所有权转移）==========
    SimpleUniquePtr(SimpleUniquePtr&& other) noexcept             // 移动构造
        : raw_ptr(other.raw_ptr) {             // 接管 other 的指针
        other.raw_ptr = nullptr;               // 将 other 置空，断开它与资源的关联
    }
 
    SimpleUniquePtr& operator=(SimpleUniquePtr&& other) noexcept { // 移动赋值
        if (this != &other) {                  // 防止自赋值
            delete raw_ptr;                    // 先释放自己当前管理的资源
            raw_ptr = other.raw_ptr;           // 接管 other 的指针
            other.raw_ptr = nullptr;           // 将 other 置空
        }
        return *this;
    }
 
    // 解引用运算符，模拟裸指针的行为
    T& operator*() const { return *raw_ptr; }  // *ptr
    T* operator->() const { return raw_ptr; }  // ptr->member
 
    // 获取底层裸指针（不转移所有权）
    T* get() const { return raw_ptr; }
 
    // 释放所有权，返回裸指针，自己不再管理
    T* release() {
        T* tmp = raw_ptr;                      // 暂存当前指针
        raw_ptr = nullptr;                     // 自身置空
        return tmp;                            // 返回裸指针，调用者负责释放
    }
 
    // 重置：释放旧资源，接管新资源
    void reset(T* p = nullptr) {
        delete raw_ptr;                        // 释放旧资源
        raw_ptr = p;                           // 接管新指针（可以为空）
    }
};

#include <memory>
 
int main() {
    auto p1 = std::make_unique<int>(100);      // p1 拥有一个值为 100 的 int
 
    // std::unique_ptr<int> p2 = p1;           // ❌ 编译错误！拷贝构造被 delete
    // std::unique_ptr<int> p3;
    // p3 = p1;                                // ❌ 编译错误！拷贝赋值被 delete
 
    // 编译器报错信息类似：
    // error: call to deleted constructor of 'std::unique_ptr<int>'
    // note: 'unique_ptr' has been explicitly marked deleted here
 
    return 0;
}

#include <memory>
#include <iostream>
 
class Sensor {
public:
    std::string name;                           // 传感器名称
    Sensor(std::string n) : name(std::move(n)) {
        std::cout << "Sensor [" << name << "] 创建\n";
    }
    ~Sensor() {
        std::cout << "Sensor [" << name << "] 销毁\n";
    }
};
 
int main() {
    // 阶段1：p1 独占 Sensor 对象
    auto p1 = std::make_unique<Sensor>("Temperature");  // 创建 Sensor
    std::cout << "p1 是否有效: " << (p1 ? "是" : "否") << "\n";   // 是
 
    // 阶段2：所有权从 p1 转移到 p2
    std::unique_ptr<Sensor> p2 = std::move(p1);         // p1 → p2 移动
 
    std::cout << "移动后:\n";
    std::cout << "  p1 是否有效: " << (p1 ? "是" : "否") << "\n"; // 否（已被掏空）
    std::cout << "  p2 是否有效: " << (p2 ? "是" : "否") << "\n"; // 是
 
    // ⚠️ 此时访问 p1 是未定义行为之前的状态——p1 为 nullptr
    // p1->name;  // 💥 解引用空指针，未定义行为！
 
    // 阶段3：可以给 p1 重新赋一个新对象
    p1 = std::make_unique<Sensor>("Humidity");           // p1 重新拥有新对象
 
    std::cout << "  p1 管理的传感器: " << p1->name << "\n";       // Humidity
    std::cout << "  p2 管理的传感器: " << p2->name << "\n";       // Temperature
 
    return 0;
}   // p1、p2 依次析构，各自管理的 Sensor 自动释放

#include <memory>
#include <iostream>
 
int main() {
    // ===== get() =====
    auto p = std::make_unique<int>(42);
    int* raw = p.get();                  // 获取裸指针，p 仍然拥有资源
    std::cout << *raw << "\n";           // 42（通过裸指针访问）
    // 注意：不要 delete raw！p 仍在管理这块内存
 
    // ===== release() =====
    int* extracted = p.release();        // p 放弃所有权，变成 nullptr
    std::cout << (p == nullptr) << "\n"; // 1（true，p 已经为空）
    std::cout << *extracted << "\n";     // 42（内存还在，但现在你自己负责）
    delete extracted;                    // ⬅️ 必须手动释放！release 不会帮你 delete
 
    // ===== reset() =====
    auto q = std::make_unique<int>(10);  // q 管理值为 10 的 int
    q.reset(new int(20));                // 释放旧的(10)，接管新的(20)
    std::cout << *q << "\n";             // 20
    q.reset();                           // 释放当前资源，q 变成 nullptr
    std::cout << (q == nullptr) << "\n"; // 1（true）
 
    // ===== swap() =====
    auto a = std::make_unique<int>(1);   // a → 1
    auto b = std::make_unique<int>(2);   // b → 2
    a.swap(b);                           // 交换！a → 2, b → 1
    std::cout << *a << ", " << *b << "\n"; // 2, 1
 
    return 0;
}

#include <memory>
#include <iostream>
 
class Engine {
public:
    int horsepower;                                     // 马力
    Engine(int hp) : horsepower(hp) {
        std::cout << "Engine(" << hp << "hp) 创建\n";
    }
    ~Engine() {
        std::cout << "Engine(" << horsepower << "hp) 销毁\n";
    }
};
 
// 函数接收 unique_ptr 的值 → 调用者必须 move → 所有权转移给函数
void installEngine(std::unique_ptr<Engine> engine) {    // 值传递，触发移动构造
    std::cout << "安装引擎，马力: " << engine->horsepower << "\n";
}   // engine 在函数结束时析构，资源被释放
 
int main() {
    auto eng = std::make_unique<Engine>(300);            // 创建引擎
    installEngine(std::move(eng));                       // 必须 std::move，所有权交出
    // installEngine(eng);                               // ❌ 编译错误：不能拷贝
    std::cout << "eng 是否有效: " << (eng ? "是" : "否") << "\n"; // 否
    return 0;
}

#include <memory>
#include <iostream>
 
class Widget {
public:
    int id;
    Widget(int i) : id(i) {
        std::cout << "Widget #" << id << " 创建\n";
    }
    ~Widget() {
        std::cout << "Widget #" << id << " 销毁\n";
    }
};
 
// 工厂函数：创建并返回 unique_ptr
// 返回值是 unique_ptr → 告诉调用者："你获得了这个对象的所有权"
std::unique_ptr<Widget> createWidget(int id) {
    auto w = std::make_unique<Widget>(id);               // 在函数内创建
    return w;                                            // ✅ 编译器自动 move（NRVO 或隐式移动）
    // 注意：这里不需要写 std::move(w)，编译器足够聪明
}
 
int main() {
    auto w1 = createWidget(1);                           // 调用者获得所有权
    auto w2 = createWidget(2);                           // 每个 widget 有独立的 owner
 
    std::cout << "w1 = Widget #" << w1->id << "\n";     // Widget #1
    std::cout << "w2 = Widget #" << w2->id << "\n";     // Widget #2
 
    return 0;
}   // w2 先析构，再 w1（栈上 LIFO 顺序）

// 只是"借用"资源，不夺取所有权
void inspect(const std::unique_ptr<Widget>& ptr) {      // const 引用，只读借用
    if (ptr) {
        std::cout << "检查 Widget #" << ptr->id << "\n";
    }
}
 
// 更推荐的做法：如果函数不关心智能指针本身，直接传裸指针或引用
void inspectBetter(const Widget& widget) {               // 直接传对象引用
    std::cout << "检查 Widget #" << widget.id << "\n";
}
 
int main() {
    auto w = std::make_unique<Widget>(42);
    inspect(w);                                          // 不需要 move，所有权不变
    inspectBetter(*w);                                   // 解引用后传引用，更通用
    // w 仍然有效
    return 0;
}

#include <memory>
#include <iostream>
 
int main() {
    // 管理动态数组：使用 unique_ptr<T[]>
    auto arr = std::make_unique<int[]>(5);    // 分配 5 个 int 的数组，值初始化为 0
 
    for (int i = 0; i < 5; ++i) {
        arr[i] = i * 10;                     // 通过 operator[] 访问元素
    }
 
    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " ";          // 输出: 0 10 20 30 40
    }
    std::cout << "\n";
 
    // 注意：数组版本没有 operator* 和 operator->
    // *arr;        // ❌ 编译错误
    // arr->xxx;    // ❌ 编译错误
 
    return 0;
}   // arr 析构时调用 delete[]，正确释放整个数组

#include <memory>
#include <cstdio>                                       // C 标准 I/O
#include <iostream>
 
int main() {
    // 方式1：Lambda 作为删除器（最常用，推荐）
    auto fileDeleter = [](FILE* fp) {                   // 定义删除逻辑
        if (fp) {
            std::cout << "关闭文件\n";
            std::fclose(fp);                            // 用 fclose 而非 delete
        }
    };
 
    {
        // unique_ptr<资源类型, 删除器类型>
        std::unique_ptr<FILE, decltype(fileDeleter)> file(
            std::fopen("test.txt", "w"),                // 打开文件（C 风格）
            fileDeleter                                 // 传入删除器
        );
 
        if (file) {                                     // 检查文件是否成功打开
            std::fputs("Hello, RAII!\n", file.get());   // 写入内容
        }
    }   // 离开作用域 → 自动调用 fileDeleter → fclose
 
    // 方式2：函数指针作为删除器
    // 注意：使用函数指针会增加 unique_ptr 的大小（额外存储一个指针）
    std::unique_ptr<FILE, int(*)(FILE*)> file2(
        std::fopen("test2.txt", "w"),                   // 打开文件
        &std::fclose                                    // 直接使用 fclose 的函数指针
    );
 
    return 0;
}

// 内存布局对比（64 位系统）
 
// 默认删除器（空类优化）
// sizeof(unique_ptr<int>) == 8 字节（与裸指针相同）
// ┌──────────────────┐
// │   T* raw_ptr     │  8 bytes
// └──────────────────┘
 
// Lambda 删除器（无捕获，空类优化生效）
// sizeof == 8 字节
// ┌──────────────────┐
// │   T* raw_ptr     │  8 bytes
// └──────────────────┘
 
// 函数指针删除器
// sizeof == 16 字节（多了一个函数指针）
// ┌──────────────────┐
// │   T* raw_ptr     │  8 bytes
// ├──────────────────┤
// │  void(*)(T*)     │  8 bytes  ← 额外开销
// └──────────────────┘

#include <memory>
#include <iostream>
#include <vector>
 
class Shape {                                            // 基类
public:
    virtual void draw() const = 0;                       // 纯虚函数
    virtual ~Shape() = default;                          // ⚠️ 虚析构函数！必须！
};
 
class Circle : public Shape {                            // 派生类：圆形
public:
    void draw() const override {
        std::cout << "绘制圆形 ●\n";
    }
};
 
class Rectangle : public Shape {                         // 派生类：矩形
public:
    void draw() const override {
        std::cout << "绘制矩形 ■\n";
    }
};
 
int main() {
    // unique_ptr<基类> 可以指向派生类对象（向上转型）
    std::vector<std::unique_ptr<Shape>> shapes;          // 存储不同形状的容器
 
    shapes.push_back(std::make_unique<Circle>());        // 添加圆形
    shapes.push_back(std::make_unique<Rectangle>());     // 添加矩形
    shapes.push_back(std::make_unique<Circle>());        // 再添加一个圆形
 
    // 多态调用
    for (const auto& shape : shapes) {                   // const auto& 避免拷贝
        shape->draw();                                   // 虚函数分派，调用正确的派生类版本
    }
 
    return 0;
}   // vector 析构 → 每个 unique_ptr 析构 → 每个 Shape 被正确释放
// 输出:
// 绘制圆形 ●
// 绘制矩形 ■
// 绘制圆形 ●

// ❌ 陷阱1：同一裸指针构造两个 unique_ptr → Double Free
int* raw = new int(42);
std::unique_ptr<int> a(raw);         // a 拥有 raw
std::unique_ptr<int> b(raw);         // b 也拥有 raw → 💥 两次 delete！
 
// ✅ 正确做法：永远用 make_unique，避免接触裸指针
auto a = std::make_unique<int>(42);  // 安全，无裸指针暴露
 
// ❌ 陷阱2：move 后使用原指针
auto p = std::make_unique<int>(10);
auto q = std::move(p);
// std::cout << *p;                  // 💥 未定义行为！p 已经是 nullptr
 
// ✅ 正确做法
if (p) {                             // 先检查
    std::cout << *p;                 // 安全
}
 
// ❌ 陷阱3：get() 返回的裸指针被手动 delete
auto ptr = std::make_unique<int>(5);
int* r = ptr.get();
// delete r;                         // 💥 ptr 析构时会再次 delete → Double Free
 
// ✅ 正确做法：get() 只用于"只读借用"，绝不 delete
legacyCFunction(ptr.get());          // 传给需要裸指针的旧函数

#include <memory>
#include <vector>
#include <algorithm>
#include <iostream>
 
int main() {
    std::vector<std::unique_ptr<int>> vec;
 
    // 添加元素必须使用移动语义或 emplace
    vec.push_back(std::make_unique<int>(3));              // ✅ make_unique 返回右值，隐式移动
    vec.emplace_back(new int(1));                         // ✅ emplace 原地构造（但不推荐用 new）
    vec.push_back(std::make_unique<int>(2));              // ✅ 推荐方式
 
    // 排序：unique_ptr 支持移动，所以 sort 可以正常工作
    std::sort(vec.begin(), vec.end(),
        [](const std::unique_ptr<int>& a,                // 比较时用 const 引用
           const std::unique_ptr<int>& b) {
            return *a < *b;                              // 按指向的值排序
        }
    );
 
    for (const auto& p : vec) {                          // 遍历时用 const auto&
        std::cout << *p << " ";                          // 输出: 1 2 3
    }
    std::cout << "\n";
 
    // 从容器中取出元素（转移所有权）
    auto extracted = std::move(vec[0]);                   // 从容器中"偷"出来
    // 注意：vec[0] 现在是 nullptr，容器大小不变！
    // 通常还需要 erase 掉这个空位
 
    return 0;
}

#include <memory>
#include <iostream>
 
struct Node {
    int val;
    Node(int v) : val(v) { std::cout << "C" << v << " "; }
    ~Node() { std::cout << "D" << val << " "; }
};
 
int main() {
    auto a = std::make_unique<Node>(1);
    auto b = std::make_unique<Node>(2);
    a.reset(new Node(3));
    b = std::move(a);
    std::cout << "E ";
    return 0;
}

#include <memory>   // 智能指针头文件
#include <iostream>
 
class Sensor {
public:
    std::string name_;                              // 传感器名称
    Sensor(const std::string& n) : name_(n) {      // 构造函数
        std::cout << "Sensor [" << name_ << "] created\n";
    }
    ~Sensor() {                                     // 析构函数
        std::cout << "Sensor [" << name_ << "] destroyed\n";
    }
    void read() const {                             // 读取数据的成员函数
        std::cout << "Reading from [" << name_ << "]\n";
    }
};
 
int main() {
    // ---- 创建 shared_ptr ----
    std::shared_ptr<Sensor> sp1 = std::make_shared<Sensor>("Gyroscope");  // 推荐方式，引用计数 = 1
 
    {
        std::shared_ptr<Sensor> sp2 = sp1;   // 拷贝构造：sp2 与 sp1 共享同一对象，引用计数 = 2
        std::shared_ptr<Sensor> sp3 = sp1;   // 再次拷贝：引用计数 = 3
 
        sp2->read();                          // 通过 sp2 访问对象，完全合法
        sp3->read();                          // 通过 sp3 访问对象，完全合法
 
        std::cout << "use_count = " << sp1.use_count() << "\n";  // 输出 3
    }   // sp2, sp3 离开作用域 → 引用计数降为 1
 
    std::cout << "use_count = " << sp1.use_count() << "\n";      // 输出 1
    // sp1 离开 main 作用域 → 引用计数降为 0 → Sensor 对象被析构
}

// ====== shared_ptr 的典型内部结构（伪代码） ======
// 注意：这是概念性模型，实际实现因编译器而异
 
struct ControlBlock {                     // 控制块：堆上分配
    std::atomic<int> strong_count;        // 强引用计数（原子操作，线程安全）
    std::atomic<int> weak_count;          // 弱引用计数（原子操作，线程安全）
    Deleter deleter;                      // 删除器（可自定义）
    Allocator allocator;                  // 分配器（可自定义）
};
 
template<typename T>
class shared_ptr {                        // shared_ptr 本身只有两个裸指针大小
    T* ptr_;                              // 指向托管对象的指针
    ControlBlock* ctrl_;                  // 指向控制块的指针
};

//  Stack                          Heap (单块连续内存)
//  ┌──────────────────┐          ┌─────────────────────────────────────┐
//  │  shared_ptr sp   │          │         Control Block               │
//  │ ┌──────────────┐ │          │ ┌─────────────┬─────────────┐      │
//  │ │ ptr_ ────────┼─┼────┐    │ │ strong = 1  │ weak = 0    │      │
//  │ ├──────────────┤ │    │    │ ├─────────────┴─────────────┤      │
//  │ │ ctrl_ ───────┼─┼────┼──▶ │ │ deleter / allocator       │      │
//  │ └──────────────┘ │    │    │ ├───────────────────────────┤      │
//  └──────────────────┘    └──▶ │ │     T object (原地构造)    │      │
//                               │ │     (data members...)      │      │
//                               │ └───────────────────────────┘      │
//                               └─────────────────────────────────────┘
//                                ▲ 一次 new：控制块 + 对象在同一块内存中

//  Stack                       Heap 块 ①                 Heap 块 ②
//  ┌──────────────────┐       ┌────────────────────┐    ┌─────────────────┐
//  │  shared_ptr sp   │       │   Control Block     │    │   T object       │
//  │ ┌──────────────┐ │       │ ┌────────┬────────┐ │    │ (data members)   │
//  │ │ ptr_ ────────┼─┼──────┼─▶        │        │ │    │                  │
//  │ ├──────────────┤ │  ┌──▶│ │strong=1│weak=0  │ │    └─────────────────┘
//  │ │ ctrl_ ───────┼─┼──┘   │ ├────────┴────────┤ │              ▲
//  │ └──────────────┘ │       │ │ ptr_to_object ──┼─┼──────────────┘
//  └──────────────────┘       │ └─────────────────┘ │
//                             └────────────────────┘
//                              ▲ 两次 new：控制块和对象分别分配

#include <memory>
#include <iostream>
 
struct Widget {
    int id;
    Widget(int i) : id(i) { std::cout << "Widget " << id << " born\n"; }
    ~Widget()              { std::cout << "Widget " << id << " dead\n"; }
};
 
int main() {
    // ====== Step 1: 创建 ======
    auto sp1 = std::make_shared<Widget>(42);
    // 堆上创建: Widget(42) + ControlBlock{ strong=1, weak=0 }
    std::cout << "[Step1] strong=" << sp1.use_count() << "\n";       // 1
 
    // ====== Step 2: 拷贝构造 ======
    std::shared_ptr<Widget> sp2(sp1);               // strong: 1 → 2
    std::cout << "[Step2] strong=" << sp1.use_count() << "\n";       // 2
 
    // ====== Step 3: 拷贝赋值 ======
    std::shared_ptr<Widget> sp3;                    // sp3 为空（nullptr）
    sp3 = sp1;                                      // strong: 2 → 3
    std::cout << "[Step3] strong=" << sp1.use_count() << "\n";       // 3
 
    // ====== Step 4: 移动语义 ======
    std::shared_ptr<Widget> sp4(std::move(sp2));    // sp2 变空，sp4 接管
    // strong 计数 **不变**，仍为 3（所有权转移，无需原子操作）
    std::cout << "[Step4] strong=" << sp1.use_count() << "\n";       // 3
    std::cout << "[Step4] sp2 is " << (sp2 ? "valid" : "null") << "\n"; // null
 
    // ====== Step 5: reset ======
    sp3.reset();                                    // sp3 放弃所有权，strong: 3 → 2
    std::cout << "[Step5] strong=" << sp1.use_count() << "\n";       // 2
 
    // ====== Step 6: 重新指向新对象 ======
    sp4.reset(new Widget(99));                      // sp4 放弃 Widget(42)，strong: 2 → 1
    // sp4 现在指向新的 Widget(99)，其自身 strong = 1
    std::cout << "[Step6] sp1.strong=" << sp1.use_count() << "\n";   // 1
    std::cout << "[Step6] sp4.strong=" << sp4.use_count() << "\n";   // 1
 
    // ====== Step 7: 作用域结束 ======
    // sp4 析构 → Widget(99) strong: 1→0 → Widget 99 dead
    // sp1 析构 → Widget(42) strong: 1→0 → Widget 42 dead
}

#include <memory>
#include <iostream>
#include <cstdio>    // FILE*, fopen, fclose
 
int main() {
    // ---- 示例 1: Lambda 作为删除器管理 FILE* ----
    std::shared_ptr<FILE> filePtr(
        fopen("data.txt", "r"),           // 通过 fopen 获取 FILE*
        [](FILE* fp) {                     // 自定义删除器：用 fclose 替代 delete
            if (fp) {
                std::cout << "Closing file via custom deleter\n";
                fclose(fp);                // 正确的资源释放方式
            }
        }
    );
    // filePtr 离开作用域时，自动调用 fclose，而不是 delete
 
    // ---- 示例 2: 管理 C 风格数组 (C++17 之前) ----
    std::shared_ptr<int> arrPtr(
        new int[100],                      // 分配 int 数组
        [](int* p) {                       // 删除器必须用 delete[]
            std::cout << "Deleting array via custom deleter\n";
            delete[] p;                    // 匹配 new[] 的正确释放方式
        }
    );
 
    // ---- 示例 3: 类型擦除的威力 ----
    // 不同删除器的 shared_ptr 可以放进同一个容器！
    auto d1 = [](int* p) { delete p; };                  // 删除器 A
    auto d2 = [](int* p) { std::cout << *p; delete p; }; // 删除器 B
 
    // 类型完全相同：都是 shared_ptr<int>，尽管删除器不同
    std::shared_ptr<int> x(new int(1), d1);
    std::shared_ptr<int> y(new int(2), d2);
 
    std::vector<std::shared_ptr<int>> vec;
    vec.push_back(x);    // ✅ 合法！类型一致
    vec.push_back(y);    // ✅ 合法！删除器的差异被"擦除"了
}

#include <memory>
#include <iostream>
 
class Animal {
public:
    // 注意：这里故意没有 virtual 析构函数（教学演示用）
    ~Animal() { std::cout << "~Animal\n"; }
    virtual void speak() = 0;         // 纯虚函数
};
 
class Dog : public Animal {
public:
    ~Dog() { std::cout << "~Dog\n"; }
    void speak() override { std::cout << "Woof!\n"; }
};
 
int main() {
    // ---- 情况 A: shared_ptr 构造时知道真实类型 ----
    std::shared_ptr<Animal> pet = std::make_shared<Dog>();
    pet->speak();  // 输出 "Woof!" —— 多态正常工作
 
    // pet 析构时：make_shared<Dog>() 在控制块中记录了 Dog 的析构方式
    // 因此即使 Animal 没有 virtual 析构函数，Dog 的析构函数也会被正确调用！
    // 输出: ~Dog 然后 ~Animal
 
    // ---- 情况 B: 裸指针的灾难 ----
    // Animal* raw = new Dog();
    // delete raw;  // ⚠️ UB! ~Animal 不是 virtual，~Dog 不会被调用
}

#include <memory>
#include <thread>
#include <iostream>
 
struct Data { int value = 0; };
 
int main() {
    auto sp = std::make_shared<Data>();
 
    // ✅ 安全：各线程拷贝自己的 shared_ptr（只影响引用计数）
    auto reader = [](std::shared_ptr<Data> local_sp) {    // 按值传递 → 引用计数+1
        std::cout << local_sp->value << "\n";              // 读取托管对象
    };  // local_sp 析构 → 引用计数-1（原子操作，安全）
 
    std::thread t1(reader, sp);    // sp 被拷贝给 t1 的 local_sp
    std::thread t2(reader, sp);    // sp 被拷贝给 t2 的 local_sp
    t1.join();
    t2.join();
 
    // ❌ 危险：多线程同时修改同一个 shared_ptr 对象
    // std::shared_ptr<Data> shared_sp = sp;
    // std::thread t3([&]() { shared_sp = std::make_shared<Data>(); }); // 写
    // std::thread t4([&]() { shared_sp = std::make_shared<Data>(); }); // 写
    // 两个线程同时修改 shared_sp 的内部指针 → Data Race → UB!
 
    // ❌ 危险：多线程同时修改托管对象
    // std::thread t5([&]() { sp->value = 1; }); // 写对象
    // std::thread t6([&]() { sp->value = 2; }); // 写对象
    // shared_ptr 不保护对象本身 → 需要自行加 mutex
}

int main() {
    int* raw = new int(42);
 
    std::shared_ptr<int> sp1(raw);   // 创建控制块 A，strong = 1
    std::shared_ptr<int> sp2(raw);   // 创建控制块 B，strong = 1 ← 灾难！
 
    // sp1 和 sp2 各有自己的控制块，各自认为自己独立拥有 *raw
    // sp2 析构 → strong_B 降为 0 → delete raw  (第一次释放)
    // sp1 析构 → strong_A 降为 0 → delete raw  (第二次释放) → UB!
}

//  控制块 A (sp1 的)         控制块 B (sp2 的)
//  ┌──────────────┐         ┌──────────────┐
//  │ strong = 1   │         │ strong = 1   │
//  │ ptr ─────────┼────┐    │ ptr ─────────┼────┐
//  └──────────────┘    │    └──────────────┘    │
//                      ▼                        ▼
//                   ┌──────┐  ◄──── 同一个对象被两个控制块管理！
//                   │  42  │
//                   └──────┘
//                   💥 Double Free!

class Node {
public:
    std::shared_ptr<Node> getShared() {
        return std::shared_ptr<Node>(this);  // ❌ 致命错误！同陷阱一
    }
};
 
int main() {
    auto sp = std::make_shared<Node>();    // 控制块 A
    auto sp2 = sp->getShared();            // 控制块 B（用 this 裸指针构建）
    // 双重释放！
}

class Node : public std::enable_shared_from_this<Node> {  // CRTP 模式
public:
    std::shared_ptr<Node> getShared() {
        return shared_from_this();  // ✅ 返回与已有 shared_ptr 共享控制块的副本
    }
};
 
int main() {
    auto sp = std::make_shared<Node>();    // 控制块中记录了 weak_ptr 给 enable_shared_from_this
    auto sp2 = sp->getShared();            // ✅ sp2 与 sp 共享同一个控制块
    std::cout << sp.use_count() << "\n";   // 输出 2，正确！
}

struct A {
    std::shared_ptr<B> b_ptr;    // A 持有 B
};
struct B {
    std::shared_ptr<A> a_ptr;    // B 持有 A
};
 
int main() {
    auto a = std::make_shared<A>();   // A strong = 1
    auto b = std::make_shared<B>();   // B strong = 1
    a->b_ptr = b;                     // B strong = 2
    b->a_ptr = a;                     // A strong = 2
 
    // 离开作用域：a 析构 → A strong: 2→1 (不为0，不销毁)
    //             b 析构 → B strong: 2→1 (不为0，不销毁)
    // A 和 B 互相引用，strong 永远无法降为 0 → 内存泄漏！💀
}

#include <memory>
 
// ---- 构造 ----
std::shared_ptr<int> sp1;                         // 空指针，use_count() == 0
std::shared_ptr<int> sp2(new int(10));            // 从裸指针构造
auto sp3 = std::make_shared<int>(10);             // 推荐方式
std::shared_ptr<int> sp4(sp3);                    // 拷贝构造
std::shared_ptr<int> sp5(std::move(sp3));         // 移动构造（sp3 变空）
 
// ---- 观察 ----
sp4.get();            // 返回裸指针 int*（不影响引用计数）
sp4.use_count();      // 返回当前 strong_count
sp4.unique();         // C++17 废弃，等价于 use_count() == 1
sp4.operator bool();  // 是否持有对象（sp4 != nullptr）
*sp4;                 // 解引用
sp4.operator->();     // 成员访问
 
// ---- 修改 ----
sp4.reset();                  // 放弃所有权，变为空（strong_count--）
sp4.reset(new int(20));       // 放弃旧对象，接管新对象
sp4.swap(sp5);                // 交换两个 shared_ptr 的内容（高效，无原子操作）
 
// ---- 比较 ----
sp4 == sp5;           // 比较持有的裸指针是否相同
sp4 == nullptr;       // 是否为空
sp4 < sp5;            // 基于裸指针地址排序（可放入 std::set）
 
// ---- 类型转换 ----
std::static_pointer_cast<Derived>(base_sp);       // 等价于 static_cast
std::dynamic_pointer_cast<Derived>(base_sp);      // 等价于 dynamic_cast（失败返回空）
std::const_pointer_cast<NonConst>(const_sp);      // 去 const
std::reinterpret_pointer_cast<Other>(sp);         // C++17，慎用

#include <memory>
#include <iostream>
 
struct Outer {
    int inner_value = 99;       // 内嵌的子对象
};
 
int main() {
    auto outer_sp = std::make_shared<Outer>();   // 管理整个 Outer 对象
 
    // 别名构造：sp_inner 与 outer_sp 共享控制块，但指向 inner_value
    std::shared_ptr<int> sp_inner(outer_sp, &outer_sp->inner_value);
 
    std::cout << *sp_inner << "\n";                    // 输出 99
    std::cout << outer_sp.use_count() << "\n";         // 输出 2（共享控制块）
 
    outer_sp.reset();   // outer_sp 放弃所有权，strong: 2 → 1
    // Outer 对象仍然活着！因为 sp_inner 仍持有控制块的强引用
 
    std::cout << *sp_inner << "\n";                    // 仍然输出 99，安全！
    // sp_inner 析构 → strong: 1 → 0 → Outer 对象被销毁
}

//  sp_inner                       outer_sp (已 reset)
//  ┌──────────────────┐
//  │ ptr_ ──────────┐ │           (nullptr)
//  │ ctrl_ ─────┐   │ │
//  └────────────┼───┼─┘
//               │   │
//               ▼   │    Heap
//  ┌────────────────────────────────────────┐
//  │ ControlBlock  │      Outer Object      │
//  │ strong = 1    │  ┌─────────────────┐   │
//  │ weak = 0      │  │ inner_value: 99 │ ◄─┘  ← sp_inner->ptr_ 指向这里
//  │               │  └─────────────────┘   │
//  └────────────────────────────────────────┘

#include <memory>
#include <iostream>
 
int main() {
    auto sp1 = std::make_shared<int>(10);
    auto sp2 = sp1;
    auto sp3 = std::move(sp1);
 
    std::cout << sp1.use_count() << " "
              << sp2.use_count() << " "
              << sp3.use_count() << "\n";
}

int* raw = new int(42);

#include <iostream>
#include <memory>
#include <string>
 
class Person {
public:
    std::string name;                          // 人物名称
    std::shared_ptr<Person> best_friend;       // 用 shared_ptr 指向"最好的朋友"
 
    Person(const std::string& n) : name(n) {   // 构造函数
        std::cout << name << " created.\n";
    }
    ~Person() {                                 // 析构函数——如果看不到这条输出，说明泄漏了
        std::cout << name << " destroyed.\n";
    }
};
 
int main() {
    // 在一个局部作用域中创建两个 Person
    {
        auto alice = std::make_shared<Person>("Alice");   // Alice 引用计数 = 1
        auto bob   = std::make_shared<Person>("Bob");     // Bob   引用计数 = 1
 
        // 建立双向好友关系
        alice->best_friend = bob;    // Bob   引用计数 = 2（alice 局部变量 + Alice 的成员）
        bob->best_friend   = alice;  // Alice 引用计数 = 2（bob   局部变量 + Bob   的成员）
 
        // 作用域结束：
        //   alice 局部变量销毁 → Alice 引用计数 从 2 降到 1（≠0，不释放）
        //   bob   局部变量销毁 → Bob   引用计数 从 2 降到 1（≠0，不释放）
    }
    // Alice 和 Bob 互相引用，计数永远不会归零 → 内存泄漏！
    std::cout << "End of main.\n";
    return 0;
}

// ============ 循环引用计数变化时间线 ============
//
// 时刻 T1: 创建 alice, bob
//   ┌───────────┐          ┌───────────┐
//   │  Alice     │          │  Bob      │
//   │ strong = 1 │          │ strong = 1│
//   └───────────┘          └───────────┘
//       ↑                       ↑
//     alice                    bob       (局部 shared_ptr 各持有一份)
//
// 时刻 T2: alice->best_friend = bob;  bob->best_friend = alice;
//   ┌───────────┐  shared   ┌───────────┐
//   │  Alice     │ ───────► │  Bob      │
//   │ strong = 2 │ ◄─────── │ strong = 2│
//   └───────────┘  shared   └───────────┘
//       ↑                       ↑
//     alice                    bob
//
// 时刻 T3: 离开作用域, 局部变量 alice 和 bob 析构
//   ┌───────────┐  shared   ┌───────────┐
//   │  Alice     │ ───────► │  Bob      │
//   │ strong = 1 │ ◄─────── │ strong = 1│
//   └───────────┘  shared   └───────────┘
//
//   没有外部指针能触及它们, 但 strong ≠ 0 → 永远不会释放 → 泄漏!

#include <iostream>
#include <memory>
 
int main() {
    std::weak_ptr<int> wp;                      // 默认构造，空的 weak_ptr
 
    {
        auto sp = std::make_shared<int>(42);    // 创建 shared_ptr, strong=1, weak=0
        wp = sp;                                // weak_ptr 绑定到 sp, strong=1, weak=1
 
        std::cout << "Inside scope:\n";
        std::cout << "  expired?   " << std::boolalpha << wp.expired() << "\n";   // false
        std::cout << "  use_count: " << wp.use_count() << "\n";                   // 1
 
        if (auto locked = wp.lock()) {          // lock() 返回有效 shared_ptr, strong 临时变为 2
            std::cout << "  value:     " << *locked << "\n";                      // 42
        }
        // locked 离开 if 作用域, strong 回到 1
    }
    // sp 离开作用域, strong = 0, 对象被销毁; weak = 1 (控制块仍存活)
 
    std::cout << "Outside scope:\n";
    std::cout << "  expired?   " << std::boolalpha << wp.expired() << "\n";       // true
    std::cout << "  use_count: " << wp.use_count() << "\n";                       // 0
 
    if (auto locked = wp.lock()) {              // lock() 返回空 shared_ptr
        std::cout << "  value: " << *locked << "\n";    // 不会执行
    } else {
        std::cout << "  Object has been destroyed.\n";   // ✅ 执行这里
    }
 
    return 0;
}

#include <iostream>
#include <memory>
#include <string>
 
class Person {
public:
    std::string name;
    std::shared_ptr<Person> best_friend;   // 强引用：我"拥有"我最好的朋友的引用
    std::weak_ptr<Person>   known_by;      // 弱引用：知道谁把我当最好的朋友，但我不"拥有"他
 
    Person(const std::string& n) : name(n) {
        std::cout << name << " created.\n";
    }
    ~Person() {
        std::cout << name << " destroyed.\n";
    }
 
    // 安全地打印 "被谁视为好友" 的信息
    void print_known_by() const {
        if (auto sp = known_by.lock()) {            // 尝试提升为 shared_ptr
            std::cout << name << " is known by " << sp->name << "\n";
        } else {
            std::cout << name << " is known by nobody (expired).\n";
        }
    }
};
 
int main() {
    {
        auto alice = std::make_shared<Person>("Alice");  // Alice strong=1
        auto bob   = std::make_shared<Person>("Bob");    // Bob   strong=1
 
        alice->best_friend = bob;     // Alice 拥有 Bob → Bob strong=2
        bob->known_by      = alice;   // Bob "知道" Alice，但不拥有 → Alice strong 仍=1 ✅
 
        alice->print_known_by();      // Alice is known by nobody (expired).
        bob->print_known_by();        // Bob is known by Alice
 
        std::cout << "Alice use_count: " << alice.use_count() << "\n";  // 1
        std::cout << "Bob   use_count: " << bob.use_count()   << "\n";  // 2
    }
    // 离开作用域:
    //   alice 销毁 → Alice strong: 1→0 → Alice 对象被销毁
    //                 → Alice 对象内 best_friend (指向 Bob) 被销毁 → Bob strong: 2→1
    //   bob   销毁 → Bob strong: 1→0 → Bob 对象被销毁 ✅
    //
    // 输出:
    //   Alice destroyed.
    //   Bob destroyed.
 
    std::cout << "End of main. No leak!\n";
    return 0;
}

#include <iostream>
#include <memory>
#include <string>
#include <vector>
 
class TreeNode {
public:
    std::string name;
    std::vector<std::shared_ptr<TreeNode>> children;  // 父拥有子：shared_ptr
    std::weak_ptr<TreeNode> parent;                    // 子观察父：weak_ptr ✅
 
    TreeNode(const std::string& n) : name(n) {
        std::cout << "  [+] " << name << " created.\n";
    }
    ~TreeNode() {
        std::cout << "  [-] " << name << " destroyed.\n";
    }
 
    // 添加子节点，并设置子节点的 parent 指针
    void add_child(std::shared_ptr<TreeNode> child) {
        child->parent = std::shared_ptr<TreeNode>(
            // 不能用 this 直接构造 shared_ptr!
            // 需要该类继承 enable_shared_from_this，这里简化处理
        );
        // 简化版：由外部设置 parent
        children.push_back(std::move(child));          // 移动语义，避免不必要的引用计数操作
    }
 
    // 安全打印父节点名称
    void print_parent() const {
        if (auto p = parent.lock()) {                  // 尝试锁定
            std::cout << "  " << name << "'s parent: " << p->name << "\n";
        } else {
            std::cout << "  " << name << " has no parent (root).\n";
        }
    }
};
 
int main() {
    std::cout << "=== Building tree ===\n";
    {
        auto root  = std::make_shared<TreeNode>("Root");      // Root strong=1
        auto childA = std::make_shared<TreeNode>("ChildA");   // ChildA strong=1
        auto childB = std::make_shared<TreeNode>("ChildB");   // ChildB strong=1
 
        // 建立父子关系
        childA->parent = root;       // Root weak+1（不影响 strong count）
        childB->parent = root;       // Root weak+1
 
        root->children.push_back(childA);   // ChildA strong=2
        root->children.push_back(childB);   // ChildB strong=2
 
        childA->print_parent();      // ChildA's parent: Root
        childB->print_parent();      // ChildB's parent: Root
 
        std::cout << "  Root   use_count: " << root.use_count()   << "\n";  // 1 ✅ (没被 shared_ptr 循环引用)
        std::cout << "  ChildA use_count: " << childA.use_count() << "\n";  // 2
        std::cout << "  ChildB use_count: " << childB.use_count() << "\n";  // 2
    }
    std::cout << "=== Tree destroyed ===\n";
 
    return 0;
}

// ============ 所有权方向决定指针类型 ============
//
//        ┌──────────────┐
//        │     Root     │
//        │  (strong=1)  │
//        └──┬───────┬───┘
//  shared_ptr│       │shared_ptr     ← 父"拥有"子 → 用 shared_ptr
//        ┌──▼──┐ ┌──▼──┐
//        │ A   │ │ B   │
//        └──┬──┘ └──┬──┘
//  weak_ptr │       │ weak_ptr      ← 子"观察"父 → 用 weak_ptr
//           ▼       ▼
//        (指向 Root, 不增加 strong count)

// ❌ 错误模式：expired() + lock() 分两步，不是原子的
if (!wp.expired()) {
    // 在这里，另一个线程可能恰好释放了最后一个 shared_ptr
    auto sp = wp.lock();   // 可能得到空的 shared_ptr！
    *sp;                   // 未定义行为！
}
 
// ✅ 正确模式：直接用 lock()，一步到位
if (auto sp = wp.lock()) {
    // sp 是有效的 shared_ptr，对象在此作用域内保证存活
    use(*sp);              // 安全
}

// ❌ 绝对禁止！这会创建一个独立的控制块，导致同一对象被 delete 两次！
std::shared_ptr<Foo> bad_ptr(this);

#include <iostream>
#include <memory>
 
class Widget : public std::enable_shared_from_this<Widget> {
    // enable_shared_from_this 内部持有一个 weak_ptr<Widget>
    // 当第一个 shared_ptr<Widget> 被创建时，这个 weak_ptr 会被自动初始化
public:
    std::string tag;
 
    Widget(const std::string& t) : tag(t) {}
 
    // 安全地获取指向自身的 shared_ptr
    std::shared_ptr<Widget> get_self() {
        return shared_from_this();       // 内部调用 weak_ptr::lock()
    }
 
    void register_callback() {
        // 典型场景：把自身注册到某个异步回调系统中
        auto self = shared_from_this();  // strong count +1, 保证回调执行时对象存活
        // async_system.register(self, ...);
        std::cout << "Registered: " << self->tag
                  << " (use_count=" << self.use_count() << ")\n";
    }
};
 
int main() {
    auto w = std::make_shared<Widget>("MyWidget");   // 此时内部 weak_ptr 被初始化
    w->register_callback();                          // use_count 临时为 2
 
    std::cout << "Final use_count: " << w.use_count() << "\n";  // 回到 1
    return 0;
}

#include <iostream>
#include <memory>
#include <unordered_map>
#include <string>
 
class Texture {
public:
    std::string name;
    Texture(const std::string& n) : name(n) {
        std::cout << "  [Load] " << name << " from disk.\n";   // 模拟耗时加载
    }
    ~Texture() {
        std::cout << "  [Free] " << name << " released.\n";
    }
};
 
class TextureCache {
    // 缓存只持有 weak_ptr: 不阻止纹理被释放
    std::unordered_map<std::string, std::weak_ptr<Texture>> cache_;
 
public:
    std::shared_ptr<Texture> get(const std::string& name) {
        auto it = cache_.find(name);                        // 查找缓存
        if (it != cache_.end()) {
            if (auto sp = it->second.lock()) {              // 尝试提升
                std::cout << "  [Hit]  " << name << " from cache.\n";
                return sp;                                  // 缓存命中，返回已有对象
            }
            // weak_ptr 已过期，纹理已被释放
            cache_.erase(it);                               // 清理过期条目
        }
        // 缓存未命中或已过期，重新加载
        auto sp = std::make_shared<Texture>(name);          // 从磁盘加载
        cache_[name] = sp;                                  // 存入 weak_ptr
        return sp;
    }
};
 
int main() {
    TextureCache cache;
 
    {
        auto t1 = cache.get("sky.png");     // [Load] sky.png from disk.
        auto t2 = cache.get("sky.png");     // [Hit]  sky.png from cache.
        // t1 和 t2 共享同一对象, strong count = 2
    }
    // t1, t2 离开作用域 → Texture 被销毁
 
    auto t3 = cache.get("sky.png");          // [Load] sky.png from disk. (重新加载)
 
    return 0;
}

struct Node {
    std::shared_ptr<Node> next;
    std::shared_ptr<Node> prev;
};
 
int main() {
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();
    a->next = b;
    b->prev = a;
}

// 假设有一个接收两个智能指针的函数
void process(std::shared_ptr<Widget> pw, std::shared_ptr<Gadget> pg);
 
// ❌ 危险的调用方式：直接在函数参数中 new
process(
    std::shared_ptr<Widget>(new Widget),   // 步骤 A: new Widget → 构造 shared_ptr
    std::shared_ptr<Gadget>(new Gadget)    // 步骤 B: new Gadget → 构造 shared_ptr
);

// ✅ 安全的调用方式
process(
    std::make_shared<Widget>(),   // 分配和构造在一步完成,要么全成功,要么全失败
    std::make_shared<Gadget>()    // 即使抛异常,前一个已被 shared_ptr 保护
);

#include <memory>   // 智能指针头文件
#include <iostream>
#include <vector>
 
class Sensor {
public:
    // 带参构造函数
    Sensor(int id, double threshold)
        : id_(id), threshold_(threshold) {
        std::cout << "Sensor " << id_ << " created\n";
    }
 
    ~Sensor() {
        std::cout << "Sensor " << id_ << " destroyed\n";
    }
 
    void report() const {
        std::cout << "Sensor " << id_ << ": threshold=" << threshold_ << "\n";
    }
 
private:
    int id_;              // 传感器 ID
    double threshold_;    // 阈值
};
 
int main() {
    // ✅ 推荐写法：make_unique 自动推导模板参数,将构造函数参数完美转发
    auto sensor1 = std::make_unique<Sensor>(1, 3.14);   // 构造 Sensor(1, 3.14)
    sensor1->report();                                    // 调用成员函数
 
    // ❌ 旧式写法（不推荐,存在异常安全隐患）
    // std::unique_ptr<Sensor> sensor2(new Sensor(2, 2.72));
 
    // ✅ 创建数组类型的 unique_ptr（C++14 起）
    auto arr = std::make_unique<int[]>(5);   // 创建包含 5 个 int 的数组,值初始化为 0
    for (int i = 0; i < 5; ++i) {
        arr[i] = i * 10;                     // 通过下标访问数组元素
        std::cout << arr[i] << " ";          // 输出: 0 10 20 30 40
    }
    std::cout << "\n";
 
    // ✅ 在容器中使用
    std::vector<std::unique_ptr<Sensor>> sensors;          // 存储独占指针的容器
    sensors.push_back(std::make_unique<Sensor>(3, 1.0));   // 直接构造并移入容器
    sensors.push_back(std::make_unique<Sensor>(4, 2.0));   // 无需手动 new
    // 离开作用域时,vector 析构 → 每个 unique_ptr 析构 → 每个 Sensor 被 delete
 
    return 0;
}

// 简化版 make_unique 实现（非数组版本）
// 帮助理解其内部工作原理
namespace my {
 
    template<typename T, typename... Args>              // 可变参数模板
    std::unique_ptr<T> make_unique(Args&&... args) {    // 万能引用接收所有参数
        // 1. 使用 new 在堆上分配内存
        // 2. 使用 std::forward 完美转发参数给 T 的构造函数
        // 3. 将裸指针包装进 unique_ptr 并返回
        return std::unique_ptr<T>(
            new T(std::forward<Args>(args)...)          // 完美转发 + new
        );
    }
 
    // 数组版本的特化
    template<typename T>
    std::unique_ptr<T> make_unique(std::size_t size) {              // 接收数组大小
        // 对数组类型使用 new[] 并值初始化（零初始化）
        return std::unique_ptr<T>(
            new std::remove_extent_t<T>[size]()         // new int[size]() 值初始化
        );
    }
 
} // namespace my