shared_ptr和weak_ptr原理

template <typename T>
struct control_block {
    size_t use_count;  // 强引用计数
    size_t weak_count; // 弱引用计数
    T* ptr;            // 指向托管对象的裸指针
    std::function<void(T*)> deleter;  // 删除器,删对象用的

    // 构造函数初始化
    control_block(T* p, std::function<void(T*)> d)
        : use_count(1), weak_count(0), ptr(p), deleter(d) {}
};



template <typename T>
class shared_ptr {
private:
    control_block<T>* ctrl_block;  // 控制块

public:
    shared_ptr(T* p, std::function<void(T*)> deleter= std::default_delete<T>())
        : ctrl_block(new control_block<T>(p, deleter)) {}


    ~shared_ptr() {
        // 销毁控制块并删除对象
        if (--ctrl_block->use_count == 0) {
            ctrl_block->deleter(ctrl_block->ptr);  // 删除对象
            if (ctrl_block->weak_count == 0) {
                delete ctrl_block;  // 删除控制块
            }
        }
    }

    // 拷贝构造函数，增加引用计数
    shared_ptr(const shared_ptr& other)
        : ctrl_block(other.ctrl_block) {
        ++ctrl_block->use_count;
    }

      
    shared_ptr(const weak_ptr& other)
        : ctrl_block(other.ctrl_block) {
         ++ctrl_block->use_count;
    }

    // 获取托管对象
    T* get() const { return ctrl_block->ptr; }

    // 返回控制块
    control_block<T>* get_control_block() const { return ctrl_block; }
};

template <typename T>
class weak_ptr {
private:
    control_block<T>* ctrl_block;  // 控制块

public:
    weak_ptr() : ctrl_block(nullptr) {}

    weak_ptr(const shared_ptr<T>& sp) : ctrl_block(sp.get_control_block()) {
        ++ctrl_block->weak_count;  // 增加弱引用计数
    }

    ~weak_ptr() {
        if (ctrl_block && --ctrl_block->weak_count == 0 && ctrl_block->use_count == 0) {
            delete ctrl_block;  // 控制块被销毁
        }
    }

    // 尝试获取 shared_ptr
    shared_ptr<T> lock() const {
        if (ctrl_block && ctrl_block->use_count > 0) {
            return shared_ptr<T>(*this);  // 转换为 shared_ptr
        }
        return shared_ptr<T>();  // 返回空的 shared_ptr
    }
};

1.为什么用对象指针去创建两个智能指针他们的计数会分开计数？因为有两个控制块，各管理各的

2.强引用计数用来维持对象的生命周期，弱引用计数用来解决循环引用的问题