1. 从 shared_ptr 到 weak_ptr 的完整实现
在C++开发中，内存管理一直是个令人头疼的问题。传统裸指针(raw pointer)虽然灵活，但需要开发者手动管理内存生命周期，稍有不慎就会导致内存泄漏或悬垂指针。智能指针的出现彻底改变了这一局面，而shared_ptr和weak_ptr这对黄金组合，更是解决了循环引用这个经典难题。
我曾在多个大型项目中深度使用智能指针，从最初的手写实现到后来的标准库应用，积累了不少实战经验。本文将带你从零开始，完整实现shared_ptr和weak_ptr的核心功能，包括引用计数、线程安全、类型转换等关键机制。不同于简单的概念讲解，我们会深入底层实现细节，并分享那些教科书上不会告诉你的性能优化技巧和典型应用场景。
2. 智能指针基础与设计思路
2.1 引用计数机制解析
引用计数是shared_ptr的核心原理。简单来说，每当我们复制一个shared_ptr时，计数器加1；当shared_ptr析构时，计数器减1。当计数器归零时，自动释放托管的内存。听起来简单，但实现起来有几个关键点需要注意：
- 计数器必须动态分配，且被所有共享同一资源的shared_ptr实例共享
- 增减引用计数必须是原子操作，保证线程安全
- 需要考虑weak_ptr的存在对引用计数的影响
下面是一个基础的控制块结构设计：
cpp复制template<typename T>
class ControlBlock {
std::atomic<size_t> shared_count;
std::atomic<size_t> weak_count;
T* ptr;
public:
explicit ControlBlock(T* p)
: shared_count(1), weak_count(0), ptr(p) {}
// 其他成员函数...
};
2.2 线程安全实现方案
在多线程环境下，引用计数的增减必须保证原子性。C++11提供的std::atomic完美解决了这个问题。但要注意，原子操作只是保证了计数器的线程安全，被管理对象本身的线程安全仍需开发者自己保证。
一个常见的误区是认为shared_ptr能保证托管对象的线程安全。实际上，shared_ptr只保证控制块的线程安全。如果多个线程同时访问同一个对象，仍需额外的同步机制。
重要提示：即使使用shared_ptr，对托管对象的并发写操作仍然需要互斥锁或其他同步机制。
3. shared_ptr的完整实现
3.1 核心数据结构设计
我们的shared_ptr实现需要包含以下核心组件：
- 指向托管对象的原始指针
- 指向控制块的指针
- 自定义删除器支持（用于处理特殊资源释放）
模板类的基本框架如下：
cpp复制template<typename T>
class SharedPtr {
T* ptr;
ControlBlock<T>* control_block;
// 辅助函数
void increment_ref() {
if (control_block) {
control_block->add_shared_ref();
}
}
void decrement_ref() {
if (control_block) {
if (control_block->release_shared_ref() == 0) {
// 最后一个shared_ptr，释放资源
delete ptr;
if (control_block->get_weak_ref() == 0) {
delete control_block;
}
}
}
}
public:
// 构造函数、析构函数、拷贝控制等...
};
3.2 关键成员函数实现
3.2.1 构造函数实现
shared_ptr有多种构造方式，我们需要实现最常见的几种：
cpp复制// 默认构造函数
SharedPtr() noexcept : ptr(nullptr), control_block(nullptr) {}
// 从原始指针构造
explicit SharedPtr(T* p) : ptr(p), control_block(new ControlBlock<T>(p)) {
if (!p) {
control_block = nullptr;
}
}
// 拷贝构造函数
SharedPtr(const SharedPtr& other) noexcept
: ptr(other.ptr), control_block(other.control_block) {
increment_ref();
}
// 移动构造函数
SharedPtr(SharedPtr&& other) noexcept
: ptr(other.ptr), control_block(other.control_block) {
other.ptr = nullptr;
other.control_block = nullptr;
}
3.2.2 析构函数实现
析构函数需要正确处理引用计数递减和资源释放：
cpp复制~SharedPtr() {
decrement_ref();
}
3.2.3 赋值运算符
赋值运算符需要考虑自赋值和资源转移：
cpp复制SharedPtr& operator=(const SharedPtr& rhs) noexcept {
if (this != &rhs) {
decrement_ref();
ptr = rhs.ptr;
control_block = rhs.control_block;
increment_ref();
}
return *this;
}
SharedPtr& operator=(SharedPtr&& rhs) noexcept {
if (this != &rhs) {
decrement_ref();
ptr = rhs.ptr;
control_block = rhs.control_block;
rhs.ptr = nullptr;
rhs.control_block = nullptr;
}
return *this;
}
3.3 辅助功能实现
3.3.1 解引用和指针访问
cpp复制T& operator*() const noexcept {
return *ptr;
}
T* operator->() const noexcept {
return ptr;
}
T* get() const noexcept {
return ptr;
}
3.3.2 使用计数查询
cpp复制size_t use_count() const noexcept {
return control_block ? control_block->get_shared_ref() : 0;
}
bool unique() const noexcept {
return use_count() == 1;
}
explicit operator bool() const noexcept {
return ptr != nullptr;
}
4. weak_ptr的实现与循环引用解决
4.1 weak_ptr的设计原理
weak_ptr是shared_ptr的观察者，它不增加引用计数，因此不会阻止对象的销毁。weak_ptr的主要用途是解决shared_ptr的循环引用问题。
weak_ptr的关键特性：
- 不增加引用计数
- 必须通过lock()方法获取可用的shared_ptr
- 当最后一个shared_ptr销毁后，即使weak_ptr存在，对象也会被释放
4.2 weak_ptr的核心实现
cpp复制template<typename T>
class WeakPtr {
T* ptr;
ControlBlock<T>* control_block;
void increment_weak() {
if (control_block) {
control_block->add_weak_ref();
}
}
void decrement_weak() {
if (control_block) {
if (control_block->release_weak_ref() == 0) {
if (control_block->get_shared_ref() == 0) {
delete control_block;
}
}
}
}
public:
WeakPtr() noexcept : ptr(nullptr), control_block(nullptr) {}
WeakPtr(const SharedPtr<T>& sp) noexcept
: ptr(sp.get()), control_block(sp.control_block) {
increment_weak();
}
~WeakPtr() {
decrement_weak();
}
SharedPtr<T> lock() const noexcept {
if (expired()) {
return SharedPtr<T>();
}
return SharedPtr<T>(*this);
}
bool expired() const noexcept {
return !control_block || control_block->get_shared_ref() == 0;
}
// 其他成员函数...
};
4.3 循环引用问题实战
循环引用是shared_ptr的典型问题。考虑以下场景：
cpp复制class Node {
public:
SharedPtr<Node> next;
SharedPtr<Node> prev;
// ...
};
auto node1 = make_shared<Node>();
auto node2 = make_shared<Node>();
node1->next = node2;
node2->prev = node1; // 循环引用！
这种情况下，即使外部不再使用node1和node2，它们的引用计数也不会归零，导致内存泄漏。解决方案是将其中一个指针改为weak_ptr：
cpp复制class Node {
public:
SharedPtr<Node> next;
WeakPtr<Node> prev; // 打破循环引用
// ...
};
5. 高级特性与性能优化
5.1 自定义删除器
标准shared_ptr支持自定义删除器，我们的实现也应该支持：
cpp复制template<typename T, typename Deleter = std::default_delete<T>>
class SharedPtr {
// ...
Deleter deleter;
void cleanup() {
if (control_block && control_block->release_shared_ref() == 0) {
deleter(ptr); // 使用自定义删除器
if (control_block->get_weak_ref() == 0) {
delete control_block;
}
}
}
// ...
};
5.2 类型转换支持
实现类似std::static_pointer_cast等类型转换函数：
cpp复制template<typename T, typename U>
SharedPtr<T> static_pointer_cast(const SharedPtr<U>& sp) noexcept {
auto p = static_cast<T*>(sp.get());
return SharedPtr<T>(sp, p);
}
template<typename T, typename U>
SharedPtr<T> dynamic_pointer_cast(const SharedPtr<U>& sp) noexcept {
if (auto p = dynamic_cast<T*>(sp.get())) {
return SharedPtr<T>(sp, p);
}
return SharedPtr<T>();
}
5.3 性能优化技巧
- make_shared优化：将对象和控制块分配在连续内存中，减少内存分配次数
- 移动语义：优先使用移动构造和移动赋值，避免不必要的引用计数操作
- 避免不必要的shared_ptr拷贝：在函数参数传递时，按const引用传递shared_ptr
- weak_ptr的谨慎使用：频繁调用lock()会有性能开销，必要时缓存结果
6. 常见问题与解决方案
6.1 多线程环境下的陷阱
-
竞态条件：虽然引用计数是原子的，但对象访问仍需同步
cpp复制// 错误示例 if (!ptr.expired()) { auto p = ptr.lock(); // 这里ptr可能已经过期 p->do_something(); } // 正确做法 if (auto p = ptr.lock()) { p->do_something(); } -
this指针问题：在类成员函数中返回shared_ptr(this)会导致多个控制块
cpp复制class Widget { public: SharedPtr<Widget> get_shared() { return SharedPtr<Widget>(this); // 危险！ } }; // 正确做法：继承enable_shared_from_this class Widget : public std::enable_shared_from_this<Widget> { public: SharedPtr<Widget> get_shared() { return shared_from_this(); } };
6.2 内存与性能问题排查
- 内存泄漏检测：定期检查use_count()，确保没有意外的引用保持
- 循环引用检测：使用工具如Valgrind或AddressSanitizer检测循环引用
- 性能分析：监控shared_ptr的构造/析构频率，避免高频操作
6.3 与标准库的兼容性问题
- STL容器中的使用：确保自定义shared_ptr满足CopyConstructible和CopyAssignable要求
- API边界：在DLL边界传递shared_ptr时，确保双方使用相同的内存分配器
- 类型擦除：shared_ptr
的特殊处理
7. 实战应用案例
7.1 观察者模式实现
cpp复制class Subject;
class Observer : public std::enable_shared_from_this<Observer> {
WeakPtr<Subject> subject;
public:
void observe(const SharedPtr<Subject>& s) {
subject = s;
// 注册逻辑...
}
void notify() {
if (auto s = subject.lock()) {
// 处理通知...
}
}
};
class Subject {
std::vector<WeakPtr<Observer>> observers;
public:
void add_observer(const SharedPtr<Observer>& obs) {
observers.emplace_back(obs);
}
void notify_observers() {
for (auto& weak_obs : observers) {
if (auto obs = weak_obs.lock()) {
obs->notify();
}
}
}
};
7.2 缓存系统设计
cpp复制template<typename Key, typename Value>
class Cache {
std::unordered_map<Key, WeakPtr<Value>> cache;
mutable std::mutex mtx;
public:
SharedPtr<Value> get(const Key& key) {
std::lock_guard<std::mutex> lock(mtx);
auto it = cache.find(key);
if (it != cache.end()) {
return it->second.lock();
}
return nullptr;
}
void store(const Key& key, const SharedPtr<Value>& value) {
std::lock_guard<std::mutex> lock(mtx);
cache[key] = value;
}
void purge_expired() {
std::lock_guard<std::mutex> lock(mtx);
for (auto it = cache.begin(); it != cache.end(); ) {
if (it->second.expired()) {
it = cache.erase(it);
} else {
++it;
}
}
}
};
7.3 多线程任务系统
cpp复制class Task : public std::enable_shared_from_this<Task> {
public:
virtual ~Task() = default;
virtual void execute() = 0;
};
class TaskScheduler {
std::vector<SharedPtr<Task>> task_queue;
std::mutex queue_mutex;
std::condition_variable cv;
bool stop_flag = false;
public:
void add_task(const SharedPtr<Task>& task) {
std::lock_guard<std::mutex> lock(queue_mutex);
task_queue.push_back(task);
cv.notify_one();
}
void run() {
while (true) {
SharedPtr<Task> task;
{
std::unique_lock<std::mutex> lock(queue_mutex);
cv.wait(lock, [this] {
return !task_queue.empty() || stop_flag;
});
if (stop_flag && task_queue.empty()) {
return;
}
task = task_queue.back();
task_queue.pop_back();
}
task->execute();
}
}
void stop() {
std::lock_guard<std::mutex> lock(queue_mutex);
stop_flag = true;
cv.notify_all();
}
};
8. 测试与验证策略
8.1 单元测试要点
-
基础功能测试：
- 空指针构造
- 原始指针构造
- 拷贝构造
- 移动构造
- 赋值操作
- 解引用操作
-
引用计数测试：
- 验证use_count()在各种操作后的正确性
- 验证对象在最后一个shared_ptr销毁时被释放
-
weak_ptr测试：
- expired()和lock()的行为验证
- 循环引用场景测试
8.2 性能测试方法
-
单线程性能：
- 构造/析构开销
- 拷贝/移动开销
- lock()操作开销
-
多线程竞争测试：
- 高并发下的引用计数正确性
- 线程间shared_ptr传递的开销
-
内存使用分析：
- 控制块大小
- 内存碎片情况
- 高频操作下的内存增长
8.3 与标准库的对比测试
-
功能兼容性：
- 接口一致性
- 类型转换行为
- 异常安全性
-
性能对比：
- 相同操作下的耗时比较
- 内存占用比较
- 多线程场景下的稳定性
9. 扩展与进阶方向
9.1 侵入式智能指针
与本文介绍的非侵入式智能指针不同，侵入式智能指针将引用计数直接存储在对象内部。这种设计可以减少内存分配次数，提高缓存局部性，但要求对象必须符合特定接口。
9.2 原子共享指针
针对高并发场景设计的原子共享指针，提供更细粒度的原子操作，适合在无锁数据结构中使用。
9.3 异构计算环境支持
考虑在GPU、FPGA等异构计算环境中使用智能指针，需要特殊的内存管理和同步机制。
9.4 调试与诊断工具
开发辅助工具用于：
- 检测智能指针的滥用
- 可视化引用关系图
- 追踪内存泄漏
- 性能热点分析
10. 经验总结与最佳实践
在实际项目中使用智能指针多年，我总结了以下黄金法则：
-
优先使用make_shared：它比直接使用shared_ptr构造函数更高效，且能避免内存泄漏风险。
-
避免裸指针与智能指针混用：一旦决定使用智能指针管理对象，就应该全程使用智能指针，避免中途混用裸指针。
-
循环引用是 silent killer：设计对象关系时，要特别注意潜在的循环引用，及时使用weak_ptr打破循环。
-
多线程环境要格外小心：虽然引用计数是原子的，但对象访问仍需同步。考虑使用shared_ptr的线程安全版本或额外同步机制。
-
性能敏感场景慎用：智能指针虽然方便，但在性能关键路径上可能会成为瓶颈，必要时可回归裸指针+手动管理。
-
自定义删除器是利器：对于特殊资源（如文件句柄、网络连接），合理使用自定义删除器可以简化资源管理。
-
类型转换要明确：使用static_pointer_cast等函数进行类型转换时，要确保转换是安全的。
-
weak_ptr的lock()结果应缓存：频繁调用lock()会有性能开销，必要时缓存结果。
-
监控use_count()：异常的use_count值往往是设计问题的信号。
-
了解你的工具：深入理解智能指针的实现原理，才能在复杂场景下做出正确决策。