编辑“︁C++ shared ptr”︁

{{DISPLAYTITLE:C++ shared_ptr}}
'''C++ shared_ptr''' 是 C++ 标准库（自 C++11 起）提供的一种智能指针，用于管理动态分配的内存资源。它通过引用计数机制实现多个指针共享同一块内存，并在最后一个引用被释放时自动销毁对象。本文详细介绍 `shared_ptr` 的用法、原理及实际应用场景。

== 简介 ==
`shared_ptr` 是 `<memory>` 头文件中定义的智能指针类模板，用于自动管理动态分配的对象生命周期。其核心特性包括：
* **共享所有权**：多个 `shared_ptr` 可以指向同一对象。
* **引用计数**：内部维护一个计数器，记录当前有多少个 `shared_ptr` 共享该对象。
* **自动释放**：当引用计数归零时，自动调用 `delete` 或自定义删除器释放资源。

== 基本用法 ==
=== 创建 shared_ptr ===
可以通过以下方式创建 `shared_ptr`：
<syntaxhighlight lang="cpp">
#include <memory>
#include <iostream>

int main() {
    // 方式1：直接构造
    std::shared_ptr<int> ptr1(new int(42));

    // 方式2：使用 make_shared（推荐）
    auto ptr2 = std::make_shared<int>(100);

    // 输出值
    std::cout << *ptr1 << ", " << *ptr2 << std::endl; // 输出: 42, 100
    return 0;
}
</syntaxhighlight>

=== 引用计数机制 ===
引用计数可通过 `use_count()` 查询：
<syntaxhighlight lang="cpp">
#include <memory>
#include <iostream>

int main() {
    auto ptr1 = std::make_shared<int>(10);
    auto ptr2 = ptr1; // 复制构造，引用计数+1

    std::cout << "引用计数: " << ptr1.use_count() << std::endl; // 输出: 2

    ptr1.reset(); // 释放ptr1的引用，计数-1
    std::cout << "引用计数: " << ptr2.use_count() << std::endl; // 输出: 1
    return 0;
}
</syntaxhighlight>

== 原理分析 ==
`shared_ptr` 内部结构包含两个关键部分：
* **指向对象的指针**：存储实际数据地址。
* **控制块**：包含引用计数、弱引用计数和删除器。

<mermaid>
graph LR
    A[shared_ptr] --> B[对象指针]
    A --> C[控制块]
    C --> D[引用计数]
    C --> E[弱引用计数]
    C --> F[删除器]
</mermaid>

数学公式表示引用计数变化：
<math>
\text{引用计数} = \sum_{i=1}^{n} \begin{cases} 
1 & \text{如果 } \text{shared\_ptr}_i \text{ 指向对象} \\
0 & \text{否则}
\end{cases}
</math>

== 高级特性 ==
=== 自定义删除器 ===
可以指定释放资源时的自定义操作：
<syntaxhighlight lang="cpp">
#include <memory>
#include <iostream>

void custom_deleter(int* p) {
    std::cout << "自定义删除器释放资源\n";
    delete p;
}

int main() {
    std::shared_ptr<int> ptr(new int(5), custom_deleter);
    return 0; // 输出: 自定义删除器释放资源
}
</syntaxhighlight>

=== 循环引用问题 ===
`shared_ptr` 可能导致循环引用，此时需结合 `weak_ptr` 解决：
<syntaxhighlight lang="cpp">
#include <memory>
#include <iostream>

struct Node {
    std::shared_ptr<Node> next;
    ~Node() { std::cout << "Node 销毁\n"; }
};

int main() {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();
    node1->next = node2;
    node2->next = node1; // 循环引用，内存泄漏！
    return 0; // 无输出，对象未销毁
}
</syntaxhighlight>

== 实际应用案例 ==
=== 场景1：资源共享 ===
在多模块系统中共享配置数据：
<syntaxhighlight lang="cpp">
#include <memory>
#include <map>

class Config {
public:
    std::map<std::string, std::string> settings;
};

void process_config(std::shared_ptr<Config> config) {
    // 多个函数共享配置
}

int main() {
    auto global_config = std::make_shared<Config>();
    process_config(global_config);
    return 0;
}
</syntaxhighlight>

=== 场景2：缓存管理 ===
实现引用计数的缓存机制：
<syntaxhighlight lang="cpp">
#include <memory>
#include <unordered_map>

class Cache {
    std::unordered_map<int, std::shared_ptr<std::string>> data;

public:
    std::shared_ptr<std::string> get(int id) {
        if (data.find(id) != data.end()) {
            return data[id];
        }
        return nullptr;
    }
};
</syntaxhighlight>

== 性能与注意事项 ==
* **优势**：避免内存泄漏，简化资源管理。
* **开销**：引用计数需要原子操作（线程安全保证）。
* **最佳实践**：
  * 优先使用 `make_shared` 而非 `new`。
  * 避免循环引用，必要时使用 `weak_ptr`。
  * 不用于管理数组（除非提供自定义删除器）。

[[Category:C++内存管理]]
[[Category:C++智能指针]]
[[Category:C++11特性]]

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 内存管理]]