实现简易版 shared_ptr ​

面试考点 ​

手写 shared_ptr 是大厂面试的高频手撕代码题。面试官考察你是否理解引用计数的原理、控制块的设计、拷贝/移动语义、自定义删除器,以及原子操作保证引用计数的线程安全。

核心概念 ​

shared_ptr 通过引用计数管理对象的生命周期:多个 shared_ptr 共享同一个控制块,控制块中的引用计数记录有多少个 shared_ptr 指向同一个对象。拷贝时计数加 1,析构时计数减 1,计数归零时删除对象。引用计数的加减必须是原子操作,保证线程安全。

基本示例 ​

cpp
#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 的单次分配优化。