一、std::shared_ptr 简介

std::shared_ptr 是 C++11 引入的智能指针，位于 <memory> 头文件中，用于管理动态分配对象的生命周期。它通过引用计数机制允许多个指针共享同一对象的拥有权，当最后一个 std::shared_ptr 被销毁或重置时，对象被自动释放。std::shared_ptr 是现代 C++ 内存管理的核心工具之一，极大地降低了手动管理内存带来的错误风险。

std::shared_ptr 的设计目标是提供一种安全、灵活的内存管理方式，解决传统裸指针容易导致的内存泄漏、悬垂指针等问题。它适用于需要多个对象共享资源、动态分配内存的场景。

二、std::shared_ptr 的特点

1. 引用计数管理：std::shared_ptr 使用引用计数跟踪共享对象的使用情况，确保对象在最后一个引用销毁时被正确释放。
2. 线程安全：引用计数的增减操作是线程安全的，但对共享对象的访问需要用户自行确保线程安全。
3. 灵活性：支持自定义删除器，允许用户指定资源释放方式。
4. 异常安全：std::shared_ptr 保证在异常发生时不会导致资源泄漏。
5. 与 std::weak_ptr 配合：通过 std::weak_ptr 解决循环引用问题。
6. 性能开销：相比裸指针，std::shared_ptr 引入了引用计数的维护开销，但在大多数场景下是可以接受的。

三、std::shared_ptr 的模块分类

std::shared_ptr 的功能可以分为以下几个模块：

1. 构造与初始化：包括通过 new、拷贝、移动等方式创建 std::shared_ptr。
2. 引用计数管理：管理对象的引用计数，提供 use_count() 查询。
3. 对象访问：通过 *、 ->、 get() 等操作访问管理的对象。
4. 资源释放：支持自定义删除器和 reset() 操作。
5. 与其他智能指针交互：与 std::unique_ptr 和 std::weak_ptr 的协作。
6. 高级功能：如 std::make_shared 优化内存分配、别名构造等。

四、应用场景

std::shared_ptr 广泛应用于以下场景：

• 共享资源管理：多个对象需要共享同一资源，如数据库连接、配置文件等。
• 复杂对象生命周期管理：在对象图中，对象的生命周期不确定，需动态管理。
• 工厂模式：工厂函数返回共享对象，确保对象在多个调用者之间安全共享。
• 多线程环境：需要多个线程访问同一资源，但不希望手动管理同步。
• 避免循环引用：结合 std::weak_ptr，解决对象间的循环引用问题。

五、详细功能模块及代码示例

以下是对每个功能模块的详细说明及代码示例。

5.1 构造与初始化

std::shared_ptr 提供了多种构造方式，包括通过 new、拷贝构造、移动构造以及 std::make_shared。

示例：基本构造与初始化

 #include <memory>
 #include <iostream>
 #include <string>
 
 void basic_construction() {
     // 通过 new 构造
     std::shared_ptr<std::string> sp1(new std::string("Hello"));
     std::cout << "sp1: " << *sp1 << ", use_count: " << sp1.use_count() << std::endl;
 
     // 拷贝构造
     std::shared_ptr<std::string> sp2 = sp1;
     std::cout << "sp2: " << *sp2 << ", use_count: " << sp2.use_count() << std::endl;
 
     // 通过 make_shared 构造
     auto sp3 = std::make_shared<std::string>("World");
     std::cout << "sp3: " << *sp3 << ", use_count: " << sp3.use_count() << std::endl;
 
     // 移动构造
     std::shared_ptr<std::string> sp4 = std::move(sp3);
     std::cout << "sp4: " << *sp4 << ", sp3 valid: " << (sp3 ? "true" : "false") 
               << ", use_count: " << sp4.use_count() << std::endl;
 }

说明：

• std::make_shared 是推荐的构造方式，它在一次内存分配中同时分配对象和控制块，效率高于单独使用 new。
• 拷贝构造会增加引用计数，移动构造不会。

5.2 引用计数管理

std::shared_ptr 通过 use_count() 查询当前引用计数，了解对象被多少个指针共享。

示例：引用计数管理

 #include <memory>
 #include <iostream>
 
 void reference_counting() {
     auto sp1 = std::make_shared<int>(42);
     std::cout << "Initial use_count: " << sp1.use_count() << std::endl;
 
     {
         auto sp2 = sp1; // 增加引用计数
         std::cout << "After copy, use_count: " << sp1.use_count() << std::endl;
     } // sp2 离开作用域，引用计数减1
 
     std::cout << "After sp2 destroyed, use_count: " << sp1.use_count() << std::endl;
 
     sp1.reset(); // 重置 sp1，引用计数变为 0，对象被销毁
     std::cout << "After reset, sp1 valid: " << (sp1 ? "true" : "false") << std::endl;
 }

说明：

• use_count() 仅用于调试或日志记录，不建议在逻辑控制中使用，因为它可能在多线程环境中不准确。
• reset() 会减少引用计数，若计数降为 0，则销毁对象。

5.3 对象访问

std::shared_ptr 提供了 *、 -> 和 get() 方法访问管理的对象。

示例：对象访问

 #include <memory>
 #include <iostream>
 #include <string>
 
 struct Person {
     std::string name;
     int age;
     void print() const { 
         std::cout << "Name: " << name << ", Age: " << age << std::endl; 
     }
 };
 
 void object_access() {
     auto person = std::make_shared<Person>(Person{"Alice", 30});
     
     // 使用 -> 访问成员
     std::cout << "Name: " << person->name << std::endl;
     
     // 使用 * 解引用
     std::cout << "Age: " << (*person).age << std::endl;
     
     // 使用 get() 获取裸指针
     Person* raw_ptr = person.get();
     raw_ptr->print();
     
     // 注意：不要手动 delete get() 返回的指针
 }

说明：

• get() 返回底层裸指针，仅用于与需要裸指针的接口交互，切勿手动删除。
• * 和 -> 提供了直观的访问方式，类似普通指针。

5.4 资源释放与自定义删除器

std::shared_ptr 支持自定义删除器，允许用户指定对象销毁时的清理逻辑。

示例：自定义删除器

 #include <memory>
 #include <iostream>
 #include <fstream>
 
 void custom_deleter() {
     // 使用自定义删除器管理文件句柄
     auto deleter = [](std::ofstream* file) {
         std::cout << "Closing file" << std::endl;
         file->close();
         delete file;
     };
     
     std::shared_ptr<std::ofstream> file_ptr(new std::ofstream("test.txt"), deleter);
     *file_ptr << "Writing to file" << std::endl;
     
     // 文件将在 file_ptr 销毁时自动关闭
 }

说明：

• 自定义删除器通过构造函数的第二个参数传递，通常是 lambda 表达式或函数对象。
• 适用于管理非内存资源，如文件句柄、网络连接等。

5.5 与其他智能指针交互

std::shared_ptr 可与 std::unique_ptr 和 std::weak_ptr 配合使用。

示例：与 std::weak_ptr 解决循环引用

 #include <memory>
 #include <iostream>
 
 struct Node {
     std::string name;
     std::weak_ptr<Node> next; // 使用 weak_ptr 避免循环引用
     ~Node() { std::cout << "Destroying " << name << std::endl; }
 };
 
 void weak_ptr_example() {
     auto node1 = std::make_shared<Node>();
     auto node2 = std::make_shared<Node>();
     
     node1->name = "Node1";
     node2->name = "Node2";
     
     node1->next = node2; // node1 指向 node2
     node2->next = node1; // node2 指向 node1
     
     // 使用 weak_ptr，引用计数不会增加
     std::cout << "node1 use_count: " << node1.use_count() << std::endl;
     
     if (auto ptr = node1->next.lock()) { // 提升为 shared_ptr
         std::cout << "node1->next: " << ptr->name << std::endl;
     }
 }

说明：

• std::weak_ptr 不增加引用计数，用于打破 std::shared_ptr 的循环引用。
• lock() 方法将 std::weak_ptr 提升为 std::shared_ptr，需检查是否有效。

5.6 高级功能：make_shared 与别名构造

std::make_shared 优化了内存分配，std::shared_ptr 还支持别名构造，用于管理子对象。

示例：make_shared 与别名构造

 #include <memory>
 #include <iostream>
 #include <vector>
 
 void advanced_features() {
     // 使用 make_shared
     auto vec = std::make_shared<std::vector<int>>(std::vector<int>{1, 2, 3});
     std::cout << "Vector size: " << vec->size() << std::endl;
     
     // 别名构造：共享 vector 的某个元素
     std::shared_ptr<int> alias_ptr(vec, &(*vec)[0]);
     std::cout << "Alias ptr points to: " << *alias_ptr << std::endl;
     
     // 修改原始 vector
     (*vec)[0] = 100;
     std::cout << "After modification, alias ptr: " << *alias_ptr << std::endl;
 }

说明：

• std::make_shared 一次性分配对象和控制块，减少内存碎片。
• 别名构造允许 std::shared_ptr 管理子对象，同时与原始对象共享引用计数。

六、注意事项与最佳实践

1. 避免循环引用：使用 std::weak_ptr 解决循环引用问题。
2. 优先使用 make_shared：比直接用 new 构造更高效且安全。
3. 不要手动删除 get() 指针：get() 返回的裸指针由 std::shared_ptr 管理。
4. 线程安全问题：引用计数操作线程安全，但对象访问需加锁保护。
5. 避免从裸指针构造多个 shared_ptr：会导致未定义行为，应始终通过拷贝或 std::make_shared 创建。

示例：错误用法与修复

 #include <memory>
 #include <iostream>
 
 void wrong_usage() {
     int* raw_ptr = new int(42);
     
     // 错误：从同一裸指针构造多个 shared_ptr
     std::shared_ptr<int> sp1(raw_ptr);
     std::shared_ptr<int> sp2(raw_ptr); // 未定义行为，可能导致双重释放
     
     // 正确：通过拷贝构造
     std::shared_ptr<int> sp3 = std::make_shared<int>(42);
     std::shared_ptr<int> sp4 = sp3; // 安全，引用计数增加
     std::cout << "sp3 use_count: " << sp3.use_count() << std::endl;
 }

七、性能与替代方案

std::shared_ptr 的引用计数机制引入了一定开销，尤其在多线程环境中。对于性能敏感场景，可考虑以下替代方案：

• std::unique_ptr：独占所有权，零开销，适合不需要共享的场景。
• 裸指针：在明确生命周期的场景下，结合 RAII 设计。
• 手动引用计数：在极高性能需求的场景下，手动实现引用计数逻辑。

性能测试示例

 #include <memory>
 #include <chrono>
 #include <iostream>
 
 void performance_test() {
     auto start = std::chrono::high_resolution_clock::now();
     
     for (int i = 0; i < 1000000; ++i) {
         auto sp = std::make_shared<int>(i);
     }
     
     auto end = std::chrono::high_resolution_clock::now();
     auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
     std::cout << "shared_ptr creation time: " << duration.count() << " us" << std::endl;
 }

八、总结

std::shared_ptr 是现代 C++ 内存管理的核心工具，通过引用计数实现了安全、灵活的资源管理。它的构造、访问、释放等功能模块覆盖了多种应用场景，从简单对象管理到复杂多线程环境均表现出色。开发者应掌握其最佳实践，避免常见陷阱，如循环引用和裸指针误用。通过合理使用 std::shared_ptr，可以显著提升代码的安全性和可维护性。