C++引用计数智能指针实现教程

实现一个简化版的C++引用计数智能指针（类似shared_ptr）的核心步骤包括：设计包含资源指针和引用计数的类，实现构造函数、拷贝构造函数、析构函数和赋值操作符重载，以及提供获取原始指针和解引用的操作符。2. 构造函数初始化资源并设置初始引用计数为1；拷贝构造函数使新对象共享资源并递增引用计数；析构函数递减引用计数并在其变为0时释放资源；赋值操作符处理自我赋值并正确释放旧资源后接管新资源。3. 通过重载*和->操作符以支持指针访问语义，并提供use_count方法查看当前引用计数值。4. 示例代码演示了该智能指针的基本用法及引用计数的变化过程，验证了其核心机制的有效性。

在C++中，实现一个简化版的引用计数智能指针（类似shared_ptr）可以帮助你理解其底层机制。下面会一步步带你写一个基础版本，虽然不考虑线程安全、自定义删除器等复杂情况，但足以展示核心原理。

基本结构设计

要实现一个带有引用计数的智能指针，我们需要两个关键部分：

• 一个资源管理类，用来持有实际的对象指针；
• 一个引用计数管理类，记录当前有多少个智能指针指向这个资源。

我们可以用一个结构体来保存这些信息：

template
class RefCountedPtr {
private:
    struct ControlBlock {
        T* ptr;
        int* ref_count;

        ControlBlock(T* p) : ptr(p), ref_count(new int(1)) {}
        ~ControlBlock() {
            delete ptr;
            delete ref_count;
        }
    };

    ControlBlock control_block;
};

当然这只是骨架，后面我们会把它封装成更像shared_ptr的形式。

实现构造与析构逻辑

我们要让多个智能指针共享同一个资源，并在最后一个指针被销毁时释放内存。

构造函数

构造函数负责初始化资源和引用计数：

template
class SimpleSharedPtr {
private:
    T* ptr;
    int* ref_count;

public:
    explicit SimpleSharedPtr(T* p = nullptr)
        : ptr(p), ref_count(new int(1)) {}

    // ...
};

拷贝构造函数

拷贝构造函数需要让新对象指向同一资源，并增加引用计数：

SimpleSharedPtr(const SimpleSharedPtr& other)
    : ptr(other.ptr), ref_count(other.ref_count) {
    ++(*ref_count);
}

析构函数

当引用计数变为0时才真正释放资源：

~SimpleSharedPtr() {
    if (--(*ref_count) == 0) {
        delete ptr;
        delete ref_count;
    }
}

赋值操作符重载

赋值操作要考虑自我赋值和旧资源释放的问题：

SimpleSharedPtr& operator=(const SimpleSharedPtr& other) {
    if (this != &other) {
        // 先减少当前引用计数
        if (--(*ref_count) == 0) {
            delete ptr;
            delete ref_count;
        }

        // 接管对方资源
        ptr = other.ptr;
        ref_count = other.ref_count;
        ++(*ref_count);
    }
    return *this;
}

获取原始指针和解引用操作

为了让我们的智能指针像普通指针一样使用，还需要重载一些操作符：

T& operator*() const { return *ptr; }
T* operator->() const { return ptr; }

T* get() const { return ptr; }

示例代码完整版

下面是简化版shared_ptr的一个最小可用实现：

#include 

template
class SimpleSharedPtr {
private:
    T* ptr;
    int* ref_count;

public:
    explicit SimpleSharedPtr(T* p = nullptr)
        : ptr(p), ref_count(new int(1)) {}

    SimpleSharedPtr(const SimpleSharedPtr& other)
        : ptr(other.ptr), ref_count(other.ref_count) {
        ++(*ref_count);
    }

    SimpleSharedPtr& operator=(const SimpleSharedPtr& other) {
        if (this != &other) {
            if (--(*ref_count) == 0) {
                delete ptr;
                delete ref_count;
            }

            ptr = other.ptr;
            ref_count = other.ref_count;
            ++(*ref_count);
        }
        return *this;
    }

    ~SimpleSharedPtr() {
        if (--(*ref_count) == 0) {
            delete ptr;
            delete ref_count;
        }
    }

    T& operator*() const { return *ptr; }
    T* operator->() const { return ptr; }

    int use_count() const { return *ref_count; }
};

int main() {
    SimpleSharedPtr p1(new int(42));
    std::cout << "Use count: " << p1.use_count() << std::endl; // 输出 1

    {
        SimpleSharedPtr p2 = p1;
        std::cout << "Use count: " << p1.use_count() << std::endl; // 输出 2
    }

    std::cout << "Use count after p2 destroyed: " << p1.use_count() << std::endl; // 输出 1
    return 0;
}

基本上就这些了。
这个版本没有考虑线程安全、自定义删除器、数组支持等功能，但在学习理解引用计数机制上已经足够。