实现简易版 shared_ptr
面试考点
手写 shared_ptr 是大厂面试的高频手撕代码题。面试官考察你是否理解引用计数的原理、控制块的设计、拷贝/移动语义、自定义删除器,以及原子操作保证引用计数的线程安全。
核心概念
shared_ptr 通过引用计数管理对象的生命周期:多个 shared_ptr 共享同一个控制块,控制块中的引用计数记录有多少个 shared_ptr 指向同一个对象。拷贝时计数加 1,析构时计数减 1,计数归零时删除对象。引用计数的加减必须是原子操作,保证线程安全。
基本示例
#include <iostream>
#include <atomic>
#include <utility>
#include <functional>
#include <cassert>
// ============================
// 控制块
// ============================
// 控制块:存储引用计数和删除器
// 所有指向同一对象的 shared_ptr 共享同一个控制块
class ControlBlock {
public:
ControlBlock() : ref_count_(1) {}
virtual ~ControlBlock() = default;
// 增加引用计数(原子操作,线程安全)
void add_ref() {
ref_count_.fetch_add(1, std::memory_order_relaxed);
}
// 减少引用计数,返回减少后的计数
// 如果计数归零,调用删除器销毁对象,然后删除控制块自身
void release() {
// fetch_sub 返回减少前的值
if (ref_count_.fetch_sub(1, std::memory_order_acq_rel) == 1) {
// 计数从 1 变为 0,是最后一个持有者
destroy_object(); // 销毁管理的对象
delete this; // 销毁控制块自身
}
}
long use_count() const {
return ref_count_.load(std::memory_order_relaxed);
}
// 子类实现:销毁管理的对象
virtual void destroy_object() = 0;
private:
std::atomic<long> ref_count_;
};
// 默认控制块:用 delete 销毁对象
template<typename T>
class DefaultControlBlock : public ControlBlock {
public:
explicit DefaultControlBlock(T* ptr) : ptr_(ptr) {}
void destroy_object() override {
delete ptr_;
}
private:
T* ptr_;
};
// 带自定义删除器的控制块
template<typename T, typename Deleter>
class CustomControlBlock : public ControlBlock {
public:
CustomControlBlock(T* ptr, Deleter deleter)
: ptr_(ptr), deleter_(std::move(deleter)) {}
void destroy_object() override {
deleter_(ptr_);
}
private:
T* ptr_;
Deleter deleter_;
};
// ============================
// SharedPtr 实现
// ============================
template<typename T>
class SharedPtr {
public:
// 默认构造:空指针
SharedPtr() noexcept : ptr_(nullptr), ctrl_(nullptr) {}
// 从裸指针构造
explicit SharedPtr(T* ptr) : ptr_(ptr), ctrl_(nullptr) {
if (ptr) {
ctrl_ = new DefaultControlBlock<T>(ptr);
}
}
// 带自定义删除器
template<typename Deleter>
SharedPtr(T* ptr, Deleter deleter) : ptr_(ptr), ctrl_(nullptr) {
if (ptr) {
ctrl_ = new CustomControlBlock<T, Deleter>(ptr, std::move(deleter));
}
}
// 拷贝构造:共享所有权,引用计数加 1
SharedPtr(const SharedPtr& other) noexcept
: ptr_(other.ptr_), ctrl_(other.ctrl_) {
if (ctrl_) {
ctrl_->add_ref();
}
}
// 移动构造:转移所有权,不改变引用计数
SharedPtr(SharedPtr&& other) noexcept
: ptr_(other.ptr_), ctrl_(other.ctrl_) {
other.ptr_ = nullptr;
other.ctrl_ = nullptr;
}
// 拷贝赋值
SharedPtr& operator=(const SharedPtr& other) noexcept {
if (this != &other) {
// 先增加新的引用计数,再减少旧的
// 这个顺序很重要:处理自赋值和异常安全
if (other.ctrl_) {
other.ctrl_->add_ref();
}
if (ctrl_) {
ctrl_->release();
}
ptr_ = other.ptr_;
ctrl_ = other.ctrl_;
}
return *this;
}
// 移动赋值
SharedPtr& operator=(SharedPtr&& other) noexcept {
if (this != &other) {
// 释放当前资源
if (ctrl_) {
ctrl_->release();
}
// 接管对方资源
ptr_ = other.ptr_;
ctrl_ = other.ctrl_;
other.ptr_ = nullptr;
other.ctrl_ = nullptr;
}
return *this;
}
// 析构:引用计数减 1
~SharedPtr() {
if (ctrl_) {
ctrl_->release();
}
}
// 解引用
T& operator*() const { return *ptr_; }
T* operator->() const { return ptr_; }
// 获取裸指针
T* get() const noexcept { return ptr_; }
// 引用计数
long use_count() const noexcept {
return ctrl_ ? ctrl_->use_count() : 0;
}
// 是否唯一持有
bool unique() const noexcept {
return use_count() == 1;
}
// 是否为空
explicit operator bool() const noexcept {
return ptr_ != nullptr;
}
// 重置
void reset() noexcept {
SharedPtr().swap(*this);
}
void reset(T* ptr) {
SharedPtr(ptr).swap(*this);
}
// 交换
void swap(SharedPtr& other) noexcept {
std::swap(ptr_, other.ptr_);
std::swap(ctrl_, other.ctrl_);
}
private:
T* ptr_; // 指向管理的对象
ControlBlock* ctrl_; // 指向控制块(引用计数 + 删除器)
};
// ============================
// make_shared 实现
// ============================
// make_shared:一次分配同时创建对象和控制块
// 标准库的 make_shared 把对象和控制块分配在同一块内存中
// 这里简化为两次分配
template<typename T, typename... Args>
SharedPtr<T> make_shared(Args&&... args) {
return SharedPtr<T>(new T(std::forward<Args>(args)...));
}
// ============================
// 比较运算符
// ============================
template<typename T>
bool operator==(const SharedPtr<T>& lhs, const SharedPtr<T>& rhs) {
return lhs.get() == rhs.get();
}
template<typename T>
bool operator!=(const SharedPtr<T>& lhs, const SharedPtr<T>& rhs) {
return lhs.get() != rhs.get();
}
template<typename T>
bool operator==(const SharedPtr<T>& lhs, std::nullptr_t) {
return lhs.get() == nullptr;
}
template<typename T>
bool operator==(std::nullptr_t, const SharedPtr<T>& rhs) {
return rhs.get() == nullptr;
}
// ============================
// 测试
// ============================
struct Widget {
int value;
Widget(int v) : value(v) {
std::cout << "Widget(" << value << ") 构造" << std::endl;
}
~Widget() {
std::cout << "Widget(" << value << ") 析构" << std::endl;
}
};
void test_basic() {
std::cout << "--- 基本用法 ---" << std::endl;
SharedPtr<Widget> p1(new Widget(1));
std::cout << "p1 计数: " << p1.use_count() << std::endl; // 1
{
SharedPtr<Widget> p2 = p1; // 拷贝,计数加 1
std::cout << "拷贝后 p1 计数: " << p1.use_count() << std::endl; // 2
std::cout << "p2 值: " << p2->value << std::endl;
SharedPtr<Widget> p3 = std::move(p2); // 移动,计数不变
std::cout << "移动后 p1 计数: " << p1.use_count() << std::endl; // 2
std::cout << "p2 是否为空: " << (!p2 ? "是" : "否") << std::endl;
}
// p2、p3 离开作用域,计数减 2→0... 不对,p2 已被移动,只有 p3 析构
std::cout << "作用域结束后 p1 计数: " << p1.use_count() << std::endl; // 1
}
void test_custom_deleter() {
std::cout << "\n--- 自定义删除器 ---" << std::endl;
// 自定义删除器:数组
SharedPtr<int> arr(new int[5], [](int* p) {
std::cout << "自定义删除器: delete[]" << std::endl;
delete[] p;
});
std::cout << "数组指针计数: " << arr.use_count() << std::endl;
}
void test_make_shared() {
std::cout << "\n--- make_shared ---" << std::endl;
auto p = make_shared<Widget>(42);
std::cout << "值: " << p->value << std::endl;
std::cout << "计数: " << p.use_count() << std::endl;
}
void test_reset() {
std::cout << "\n--- reset ---" << std::endl;
auto p1 = make_shared<Widget>(10);
auto p2 = p1;
std::cout << "reset 前计数: " << p1.use_count() << std::endl; // 2
p1.reset(); // p1 放弃所有权
std::cout << "p1 reset 后 p2 计数: " << p2.use_count() << std::endl; // 1
std::cout << "p1 是否为空: " << (!p1 ? "是" : "否") << std::endl;
}
int main() {
test_basic();
test_custom_deleter();
test_make_shared();
test_reset();
return 0;
}shared_ptr 内部结构
| 组件 | 作用 | 存储位置 |
|---|---|---|
| 对象指针 (T*) | 指向管理的对象 | SharedPtr 内部 |
| 控制块指针 | 指向控制块 | SharedPtr 内部 |
| 强引用计数 | shared_ptr 的数量 | 控制块内 |
| 弱引用计数 | weak_ptr 的数量 | 控制块内(本实现省略) |
| 删除器 | 销毁对象的方式 | 控制块内 |
关键操作的引用计数变化
| 操作 | 引用计数变化 |
|---|---|
| 构造(裸指针) | 创建控制块,计数 = 1 |
| 拷贝构造 | 计数 + 1 |
| 移动构造 | 计数不变(转移所有权) |
| 拷贝赋值 | 新的 + 1,旧的 - 1 |
| 移动赋值 | 旧的 - 1(新的转移) |
| 析构 | 计数 - 1 |
| reset() | 计数 - 1 |
| 计数归零 | 调用删除器销毁对象 |
常见问题
为什么引用计数要用原子操作?
多个线程可能同时拷贝、移动或销毁指向同一对象的 shared_ptr。如果引用计数不是原子的,两个线程同时递减可能导致计数错误:两个线程都读到 2,都减为 1,而实际应该是 0。原子操作保证递增和递减是不可分割的。
拷贝赋值中为什么先增后减?
考虑自赋值(p = p)的情况:如果先减后增,先减可能导致计数归零并删除对象,然后增就操作已释放的内存了。先增后减保证了自赋值的安全性。
make_shared 有什么优势?
标准库的 make_shared 把对象和控制块分配在同一块连续内存中(一次 new),而 shared_ptr(new T) 需要两次分配(一次 new T,一次 new 控制块)。make_shared 减少了内存分配次数和内存碎片,也更缓存友好。
这个实现和标准库的区别?
主要缺少:1) weak_ptr 支持(弱引用计数);2) enable_shared_from_this;3) make_shared 的单次分配优化;4) 类型转换(static_pointer_cast 等);5) 原子操作的内存序优化。
适用场景
- 多个对象共享同一资源的所有权
- 对象的生命周期不确定,由最后一个使用者负责销毁
- 需要把智能指针存入容器或跨线程传递
注意事项
- 避免循环引用(A 持有 B,B 持有 A → 内存泄漏),用 weak_ptr 打破循环
- 不要从裸指针创建多个独立的 shared_ptr(会导致多次删除)
- 引用计数本身是线程安全的,但对象的访问需要额外同步
- shared_ptr 的大小是裸指针的两倍(对象指针 + 控制块指针)
- 频繁拷贝 shared_ptr 有原子操作开销,考虑传引用
总结
手写 shared_ptr 的关键点:控制块存储引用计数和删除器,多个 shared_ptr 共享同一个控制块。拷贝时原子递增计数,析构时原子递减计数,计数归零时调用删除器。面试中要能写出完整的构造、拷贝、移动、析构,解释为什么引用计数用原子操作,为什么拷贝赋值要先增后减,以及 make_shared 的单次分配优化。