智能指针如何实现 引用计数模板类开发

std::shared_ptr

template <typename T>
class RefCountBlock {
public:
    T* ptr;
    int ref_count;

    explicit RefCountBlock(T* p) : ptr(p), ref_count(1) {}

    ~RefCountBlock() {
        delete ptr;
    }

    void add_ref() {
        ++ref_count;
    }

    bool release() {
        return --ref_count == 0;
    }
};

shared_ptr

template <typename T>
class SharedPtr {
private:
    T* ptr;
    RefCountBlock<T>* block;

    // 私有辅助函数：减少引用并清理
    void release() {
        if (block && block->release()) {
            delete block;  // block 析构时会 delete ptr
        }
        ptr = nullptr;
        block = nullptr;
    }

public:
    // 构造函数：接管原始指针
    explicit SharedPtr(T* p = nullptr) : ptr(p), block(nullptr) {
        if (ptr) {
            block = new RefCountBlock<T>(ptr);
        }
    }

    // 拷贝构造函数
    SharedPtr(const SharedPtr& other) : ptr(other.ptr), block(other.block) {
        if (block) {
            block->add_ref();
        }
    }

    // 赋值操作符
    SharedPtr& operator=(const SharedPtr& other) {
        if (this != &other) {
            release();  // 释放当前资源
            ptr = other.ptr;
            block = other.block;
            if (block) {
                block->add_ref();
            }
        }
        return *this;
    }

    // 析构函数
    ~SharedPtr() {
        release();
    }

    // 解引用操作
    T& operator*() const { return *ptr; }
    T* operator->() const { return ptr; }

    // 获取原始指针
    T* get() const { return ptr; }

    // 检查是否唯一引用
    bool unique() const { return block && block->ref_count == 1; }

    // 获取引用计数
    int use_count() const { return block ? block->ref_count : 0; }

    // 显式重置
    void reset(T* p = nullptr) {
        release();
        ptr = p;
        if (ptr) {
            block = new RefCountBlock<T>(ptr);
        }
    }

    // 判断是否为空
    explicit operator bool() const { return ptr != nullptr; }
};

#include <iostream>
using namespace std;

class MyClass {
public:
    MyClass(int val) : value(val) {
        cout << "MyClass created: " << value << endl;
    }
    ~MyClass() {
        cout << "MyClass destroyed: " << value << endl;
    }
    void say() { cout << "Hello from " << value << endl; }
private:
    int value;
};

int main() {
    {
        SharedPtr<MyClass> p1(new MyClass(10));
        cout << "use count: " << p1.use_count() << endl;  // 1

        {
            SharedPtr<MyClass> p2 = p1;
            cout << "use count: " << p1.use_count() << endl;  // 2
            p2->say();
        }  // p2 析构，引用计数减1

        cout << "use count: " << p1.use_count() << endl;  // 1
    }  // p1 析构，对象被删除

    return 0;
}

MyClass created: 10
use count: 1
use count: 2
Hello from 10
use count: 1
MyClass destroyed: 10