C++四个智能指针的使用小结

#include <memory>
using namespace std;
// 循环引用问题（内存泄漏）
struct A { shared_ptr<B> b; ~A() { cout << "A 析构" << endl; } };
struct B { shared_ptr<A> a; ~B() { cout << "B 析构" << endl; } };
// 用 weak_ptr 解决循环引用
struct C { shared_ptr<D> d; ~C() { cout << "C 析构" << endl; } };
struct D { weak_ptr<C> c; ~D() { cout << "D 析构" << endl; } };
int main() {
    // 1. 循环引用：析构函数不会执行，内存泄漏
    auto a = make_shared<A>();
    auto b = make_shared<B>();
    a->b = b;
    b->a = a;
    // 2. 用 weak_ptr 解决：析构函数正常执行
    auto c = make_shared<C>();
    auto d = make_shared<D>();
    c->d = d;
    d->c = c; // D 用 weak_ptr 指向 C，不增加引用计数
    return 0;
}

#include <iostream>
#include <mutex> // 引入互斥锁保证线程安全
using namespace std;
template <typename T>
class SharedPtr {
private:
    T* ptr;                // 底层资源指针
    int* use_count;        // 引用计数（指针形式，保证所有对象共享）
    mutex* mtx;            // 互斥锁（保证多线程下计数操作原子性）
    // 私有辅助函数：释放当前资源
    void release() {
        lock_guard<mutex> lock(*mtx); // 加锁保证线程安全
        if (--(*use_count) == 0) {    // 引用计数减1，若为0则释放资源
            delete ptr;               // 释放底层内存
            delete use_count;         // 释放计数内存
            delete mtx;               // 释放锁内存
            ptr = nullptr;
            use_count = nullptr;
            mtx = nullptr;
        }
    }
public:
    // 1. 构造函数：接收原始指针
    SharedPtr(T* p = nullptr) : ptr(p) {
        try {
            use_count = new int(1);   // 初始计数为1
            mtx = new mutex();        // 初始化锁
        } catch (...) {               // 内存分配失败，释放资源避免泄漏
            delete ptr;
            ptr = nullptr;
            throw; // 抛出异常，让上层处理
        }
    }
    // 2. 拷贝构造函数：共享资源，计数+1
    SharedPtr(const SharedPtr<T>& other) {
        ptr = other.ptr;
        use_count = other.use_count;
        mtx = other.mtx;
        // 加锁更新计数（多线程安全）
        lock_guard<mutex> lock(*mtx);
        ++(*use_count);
    }
    // 3. 赋值运算符重载：先释放自己的资源，再共享对方的资源
    SharedPtr<T>& operator=(const SharedPtr<T>& other) {
        // 防止自赋值（p = p）
        if (this == &other) return *this;
        // 第一步：释放当前对象持有的资源
        release();
        // 第二步：共享新对象的资源，计数+1
        ptr = other.ptr;
        use_count = other.use_count;
        mtx = other.mtx;
        lock_guard<mutex> lock(*mtx);
        ++(*use_count);
        return *this;
    }
    // 4. 析构函数：计数-1，计数为0则释放资源
    ~SharedPtr() {
        if (use_count != nullptr) { // 避免重复释放
            release();
        }
    }
    // 5. 重载解引用运算符：模拟原始指针行为
    T& operator*() const {
        if (ptr == nullptr) {
            throw runtime_error("解引用空指针");
        }
        return *ptr;
    }
    // 6. 重载->运算符：模拟原始指针行为
    T* operator->() const {
        if (ptr == nullptr) {
            throw runtime_error("访问空指针成员");
        }
        return ptr;
    }
    // 7. 获取引用计数
    int get_count() const {
        lock_guard<mutex> lock(*mtx);
        return *use_count;
    }
    // 8. 获取原始指针（谨慎使用）
    T* get() const {
        return ptr;
    }
    // 禁用移动构造/赋值（简化版，C++11后可实现）
    SharedPtr(SharedPtr<T>&&) = delete;
    SharedPtr<T>& operator=(SharedPtr<T>&&) = delete;
};
// 测试代码
int main() {
    SharedPtr<int> p1(new int(10));
    cout << "p1计数：" << p1.get_count() << endl; // 输出1
    cout << "*p1 = " << *p1 << endl;             // 输出10
    SharedPtr<int> p2 = p1;
    cout << "p1计数：" << p1.get_count() << endl; // 输出2
    cout << "p2计数：" << p2.get_count() << endl; // 输出2
    *p2 = 20;
    cout << "*p1 = " << *p1 << endl;             // 输出20（共享资源）
    SharedPtr<int> p3(new int(30));
    p2 = p3; // p2赋值给p3，p1计数变为1，p3计数变为2
    cout << "p1计数：" << p1.get_count() << endl; // 输出1
    cout << "p3计数：" << p3.get_count() << endl; // 输出2
    return 0;
}

#include <iostream>
#include <utility> // 引入move
using namespace std;

template <typename T>
class UniquePtr {
private:
    T* ptr; // 独占的底层资源指针

public:
    // 1. 构造函数：接收原始指针
    explicit UniquePtr(T* p = nullptr) : ptr(p) {}

    // 2. 禁用拷贝构造（独占所有权，禁止拷贝）
    UniquePtr(const UniquePtr<T>&) = delete;

    // 3. 禁用赋值运算符
    UniquePtr<T>& operator=(const UniquePtr<T>&) = delete;

    // 4. 移动构造函数：转移资源所有权
    UniquePtr(UniquePtr<T>&& other) noexcept {
        ptr = other.ptr;
        other.ptr = nullptr; // 源对象置空，避免重复释放
    }

    // 5. 移动赋值运算符：转移资源所有权
    UniquePtr<T>& operator=(UniquePtr<T>&& other) noexcept {
        if (this == &other) return *this;

        // 释放当前资源
        delete ptr;
        // 转移所有权
        ptr = other.ptr;
        other.ptr = nullptr;

        return *this;
    }

    // 6. 析构函数：直接释放资源（无计数，独占所以直接删）
    ~UniquePtr() {
        delete ptr;
        ptr = nullptr;
    }

    // 7. 重载解引用运算符
    T& operator*() const {
        if (ptr == nullptr) throw runtime_error("解引用空指针");
        return *ptr;
    }

    // 8. 重载->运算符
    T* operator->() const {
        if (ptr == nullptr) throw runtime_error("访问空指针成员");
        return ptr;
    }

    // 9. 释放资源（手动放弃所有权）
    T* release() {
        T* temp = ptr;
        ptr = nullptr;
        return temp;
    }

    // 10. 重置资源
    void reset(T* p = nullptr) {
        delete ptr;
        ptr = p;
    }

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

// 测试代码
int main() {
    UniquePtr<int> p1(new int(10));
    cout << "*p1 = " << *p1 << endl; // 输出10

    // UniquePtr<int> p2 = p1; // 编译错误：禁用拷贝构造
    UniquePtr<int> p2 = move(p1); // 移动构造，p1置空
    // cout << *p1 << endl; // 崩溃：p1已空
    cout << "*p2 = " << *p2 << endl; // 输出10

    p2.reset(new int(20)); // 重置资源
    cout << "*p2 = " << *p2 << endl; // 输出20

    return 0;
}

#include <iostream>
#include <mutex>
using namespace std;
// 先声明SharedPtr，供WeakPtr使用
template <typename T> class SharedPtr;
template <typename T>
class WeakPtr {
private:
    T* ptr;                // 底层资源指针（仅观察）
    int* use_count;        // 共享_ptr的强引用计数
    int* weak_count;       // 弱引用计数
    mutex* mtx;            // 共享锁
    // 私有辅助函数：释放弱引用
    void release_weak() {
        lock_guard<mutex> lock(*mtx);
        if (--(*weak_count) == 0) { // 弱引用计数为0时，释放计数内存
            delete use_count;
            delete weak_count;
            delete mtx;
            use_count = nullptr;
            weak_count = nullptr;
            mtx = nullptr;
        }
    }
public:
    // 1. 构造函数：默认构造
    WeakPtr() : ptr(nullptr), use_count(nullptr), weak_count(nullptr), mtx(nullptr) {}
    // 2. 从shared_ptr构造
    WeakPtr(const SharedPtr<T>& sp) {
        ptr = sp.get();
        use_count = sp.use_count_ptr(); // 需要SharedPtr暴露use_count指针（友元）
        weak_count = sp.weak_count_ptr();
        mtx = sp.get_mutex();
        lock_guard<mutex> lock(*mtx);
        ++(*weak_count); // 弱引用计数+1
    }
    // 3. 拷贝构造
    WeakPtr(const WeakPtr<T>& wp) {
        ptr = wp.ptr;
        use_count = wp.use_count;
        weak_count = wp.weak_count;
        mtx = wp.mtx;
        lock_guard<mutex> lock(*mtx);
        ++(*weak_count);
    }
    // 4. 赋值运算符
    WeakPtr<T>& operator=(const WeakPtr<T>& wp) {
        if (this == &wp) return *this;
        if (weak_count != nullptr) release_weak(); // 释放当前弱引用
        ptr = wp.ptr;
        use_count = wp.use_count;
        weak_count = wp.weak_count;
        mtx = wp.mtx;
        lock_guard<mutex> lock(*mtx);
        ++(*weak_count);
        return *this;
    }
    // 5. 析构函数：弱引用计数-1
    ~WeakPtr() {
        if (weak_count != nullptr) {
            release_weak();
        }
    }
    // 6. 核心方法：lock()转换为shared_ptr
    SharedPtr<T> lock() const {
        lock_guard<mutex> lock(*mtx);
        if (*use_count > 0) { // 强引用计数>0，资源未释放
            return SharedPtr<T>(ptr, use_count, weak_count, mtx); // 自定义SharedPtr构造函数
        }
        return SharedPtr<T>(); // 资源已释放，返回空shared_ptr
    }
    // 7. 检查资源是否有效（未被释放）
    bool expired() const {
        lock_guard<mutex> lock(*mtx);
        return *use_count == 0;
    }
    // 8. 获取强引用计数
    int use_count() const {
        lock_guard<mutex> lock(*mtx);
        return *use_count;
    }
    // 禁用移动构造/赋值（简化版）
    WeakPtr(WeakPtr<T>&&) = delete;
    WeakPtr<T>& operator=(WeakPtr<T>&&) = delete;
    // 友元声明：让SharedPtr访问WeakPtr的私有成员
    friend class SharedPtr<T>;
};
// 补充SharedPtr的扩展（支持WeakPtr）
template <typename T>
class SharedPtr {
private:
    T* ptr;
    int* use_count;
    int* weak_count; // 新增弱引用计数
    mutex* mtx;
    void release() {
        lock_guard<mutex> lock(*mtx);
        if (--(*use_count) == 0) {
            delete ptr;
            ptr = nullptr;
        }
        // 弱引用计数处理移交给WeakPtr
    }
    // 供WeakPtr::lock()调用的私有构造函数
    SharedPtr(T* p, int* uc, int* wc, mutex* m) : ptr(p), use_count(uc), weak_count(wc), mtx(m) {
        lock_guard<mutex> lock(*mtx);
        ++(*use_count);
    }
public:
    // 原有构造函数扩展弱引用计数
    SharedPtr(T* p = nullptr) : ptr(p) {
        try {
            use_count = new int(1);
            weak_count = new int(0); // 初始弱引用计数为0
            mtx = new mutex();
        } catch (...) {
            delete ptr;
            ptr = nullptr;
            throw;
        }
    }
    // 暴露给WeakPtr的接口
    int* use_count_ptr() const { return use_count; }
    int* weak_count_ptr() const { return weak_count; }
    mutex* get_mutex() const { return mtx; }
    // 其余方法（拷贝构造、赋值、析构等）需适配weak_count，此处省略...
    T* get() const { return ptr; }
};