C++ shared_ptr

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

简介

`shared_ptr` 是 `<memory>` 头文件中定义的智能指针类模板，用于自动管理动态分配的对象生命周期。其核心特性包括：

• **共享所有权**：多个 `shared_ptr` 可以指向同一对象。
• **引用计数**：内部维护一个计数器，记录当前有多少个 `shared_ptr` 共享该对象。
• **自动释放**：当引用计数归零时，自动调用 `delete` 或自定义删除器释放资源。

基本用法

创建 shared_ptr

可以通过以下方式创建 `shared_ptr`：

#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;
}

引用计数机制

引用计数可通过 `use_count()` 查询：

#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;
}

原理分析

`shared_ptr` 内部结构包含两个关键部分：

• **指向对象的指针**：存储实际数据地址。
• **控制块**：包含引用计数、弱引用计数和删除器。

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

数学公式表示引用计数变化： 解析失败 (未知函数“\begin{cases}”): {\displaystyle \text{引用计数} = \sum_{i=1}^{n} \begin{cases} 1 & \text{如果 } \text{shared\_ptr}_i \text{ 指向对象} \\ 0 & \text{否则} \end{cases} }

高级特性

自定义删除器

可以指定释放资源时的自定义操作：

#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; // 输出: 自定义删除器释放资源
}

循环引用问题

`shared_ptr` 可能导致循环引用，此时需结合 `weak_ptr` 解决：

#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; // 无输出，对象未销毁
}

实际应用案例

场景1：资源共享

在多模块系统中共享配置数据：

#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;
}

场景2：缓存管理

实现引用计数的缓存机制：

#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;
    }
};

性能与注意事项

• **优势**：避免内存泄漏，简化资源管理。
• **开销**：引用计数需要原子操作（线程安全保证）。
• **最佳实践**：

 * 优先使用 `make_shared` 而非 `new`。
 * 避免循环引用，必要时使用 `weak_ptr`。
 * 不用于管理数组（除非提供自定义删除器）。