#include <memory>
using namespace std;
// 循環(huán)引用問題（內(nèi)存泄漏）
struct A { shared_ptr<B> b; ~A() { cout << "A 析構(gòu)" << endl; } };
struct B { shared_ptr<A> a; ~B() { cout << "B 析構(gòu)" << endl; } };
// 用 weak_ptr 解決循環(huán)引用
struct C { shared_ptr<D> d; ~C() { cout << "C 析構(gòu)" << endl; } };
struct D { weak_ptr<C> c; ~D() { cout << "D 析構(gòu)" << endl; } };
int main() {
    // 1. 循環(huán)引用：析構(gòu)函數(shù)不會執(zhí)行，內(nèi)存泄漏
    auto a = make_shared<A>();
    auto b = make_shared<B>();
    a->b = b;
    b->a = a;
    // 2. 用 weak_ptr 解決：析構(gòu)函數(shù)正常執(zhí)行
    auto c = make_shared<C>();
    auto d = make_shared<D>();
    c->d = d;
    d->c = c; // D 用 weak_ptr 指向 C，不增加引用計數(shù)
    return 0;
}

#include <iostream>
#include <mutex> // 引入互斥鎖保證線程安全
using namespace std;
template <typename T>
class SharedPtr {
private:
    T* ptr;                // 底層資源指針
    int* use_count;        // 引用計數(shù)（指針形式，保證所有對象共享）
    mutex* mtx;            // 互斥鎖（保證多線程下計數(shù)操作原子性）
    // 私有輔助函數(shù)：釋放當(dāng)前資源
    void release() {
        lock_guard<mutex> lock(*mtx); // 加鎖保證線程安全
        if (--(*use_count) == 0) {    // 引用計數(shù)減1，若為0則釋放資源
            delete ptr;               // 釋放底層內(nèi)存
            delete use_count;         // 釋放計數(shù)內(nèi)存
            delete mtx;               // 釋放鎖內(nèi)存
            ptr = nullptr;
            use_count = nullptr;
            mtx = nullptr;
        }
    }
public:
    // 1. 構(gòu)造函數(shù)：接收原始指針
    SharedPtr(T* p = nullptr) : ptr(p) {
        try {
            use_count = new int(1);   // 初始計數(shù)為1
            mtx = new mutex();        // 初始化鎖
        } catch (...) {               // 內(nèi)存分配失敗，釋放資源避免泄漏
            delete ptr;
            ptr = nullptr;
            throw; // 拋出異常，讓上層處理
        }
    }
    // 2. 拷貝構(gòu)造函數(shù)：共享資源，計數(shù)+1
    SharedPtr(const SharedPtr<T>& other) {
        ptr = other.ptr;
        use_count = other.use_count;
        mtx = other.mtx;
        // 加鎖更新計數(shù)（多線程安全）
        lock_guard<mutex> lock(*mtx);
        ++(*use_count);
    }
    // 3. 賦值運算符重載：先釋放自己的資源，再共享對方的資源
    SharedPtr<T>& operator=(const SharedPtr<T>& other) {
        // 防止自賦值（p = p）
        if (this == &other) return *this;
        // 第一步：釋放當(dāng)前對象持有的資源
        release();
        // 第二步：共享新對象的資源，計數(shù)+1
        ptr = other.ptr;
        use_count = other.use_count;
        mtx = other.mtx;
        lock_guard<mutex> lock(*mtx);
        ++(*use_count);
        return *this;
    }
    // 4. 析構(gòu)函數(shù)：計數(shù)-1，計數(shù)為0則釋放資源
    ~SharedPtr() {
        if (use_count != nullptr) { // 避免重復(fù)釋放
            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. 獲取引用計數(shù)
    int get_count() const {
        lock_guard<mutex> lock(*mtx);
        return *use_count;
    }
    // 8. 獲取原始指針（謹(jǐn)慎使用）
    T* get() const {
        return ptr;
    }
    // 禁用移動構(gòu)造/賦值（簡化版，C++11后可實現(xiàn)）
    SharedPtr(SharedPtr<T>&&) = delete;
    SharedPtr<T>& operator=(SharedPtr<T>&&) = delete;
};
// 測試代碼
int main() {
    SharedPtr<int> p1(new int(10));
    cout << "p1計數(shù)：" << p1.get_count() << endl; // 輸出1
    cout << "*p1 = " << *p1 << endl;             // 輸出10
    SharedPtr<int> p2 = p1;
    cout << "p1計數(shù)：" << p1.get_count() << endl; // 輸出2
    cout << "p2計數(shù)：" << p2.get_count() << endl; // 輸出2
    *p2 = 20;
    cout << "*p1 = " << *p1 << endl;             // 輸出20（共享資源）
    SharedPtr<int> p3(new int(30));
    p2 = p3; // p2賦值給p3，p1計數(shù)變?yōu)?，p3計數(shù)變?yōu)?
    cout << "p1計數(shù)：" << p1.get_count() << endl; // 輸出1
    cout << "p3計數(shù)：" << 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. 構(gòu)造函數(shù)：接收原始指針
    explicit UniquePtr(T* p = nullptr) : ptr(p) {}

    // 2. 禁用拷貝構(gòu)造（獨占所有權(quán)，禁止拷貝）
    UniquePtr(const UniquePtr<T>&) = delete;

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

    // 4. 移動構(gòu)造函數(shù)：轉(zhuǎn)移資源所有權(quán)
    UniquePtr(UniquePtr<T>&& other) noexcept {
        ptr = other.ptr;
        other.ptr = nullptr; // 源對象置空，避免重復(fù)釋放
    }

    // 5. 移動賦值運算符：轉(zhuǎn)移資源所有權(quán)
    UniquePtr<T>& operator=(UniquePtr<T>&& other) noexcept {
        if (this == &other) return *this;

        // 釋放當(dāng)前資源
        delete ptr;
        // 轉(zhuǎn)移所有權(quán)
        ptr = other.ptr;
        other.ptr = nullptr;

        return *this;
    }

    // 6. 析構(gòu)函數(shù)：直接釋放資源（無計數(shù)，獨占所以直接刪）
    ~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. 釋放資源（手動放棄所有權(quán)）
    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; // 編譯錯誤：禁用拷貝構(gòu)造
    UniquePtr<int> p2 = move(p1); // 移動構(gòu)造，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的強(qiáng)引用計數(shù)
    int* weak_count;       // 弱引用計數(shù)
    mutex* mtx;            // 共享鎖
    // 私有輔助函數(shù)：釋放弱引用
    void release_weak() {
        lock_guard<mutex> lock(*mtx);
        if (--(*weak_count) == 0) { // 弱引用計數(shù)為0時，釋放計數(shù)內(nèi)存
            delete use_count;
            delete weak_count;
            delete mtx;
            use_count = nullptr;
            weak_count = nullptr;
            mtx = nullptr;
        }
    }
public:
    // 1. 構(gòu)造函數(shù)：默認(rèn)構(gòu)造
    WeakPtr() : ptr(nullptr), use_count(nullptr), weak_count(nullptr), mtx(nullptr) {}
    // 2. 從shared_ptr構(gòu)造
    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); // 弱引用計數(shù)+1
    }
    // 3. 拷貝構(gòu)造
    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(); // 釋放當(dāng)前弱引用
        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. 析構(gòu)函數(shù)：弱引用計數(shù)-1
    ~WeakPtr() {
        if (weak_count != nullptr) {
            release_weak();
        }
    }
    // 6. 核心方法：lock()轉(zhuǎn)換為shared_ptr
    SharedPtr<T> lock() const {
        lock_guard<mutex> lock(*mtx);
        if (*use_count > 0) { // 強(qiáng)引用計數(shù)>0，資源未釋放
            return SharedPtr<T>(ptr, use_count, weak_count, mtx); // 自定義SharedPtr構(gòu)造函數(shù)
        }
        return SharedPtr<T>(); // 資源已釋放，返回空shared_ptr
    }
    // 7. 檢查資源是否有效（未被釋放）
    bool expired() const {
        lock_guard<mutex> lock(*mtx);
        return *use_count == 0;
    }
    // 8. 獲取強(qiáng)引用計數(shù)
    int use_count() const {
        lock_guard<mutex> lock(*mtx);
        return *use_count;
    }
    // 禁用移動構(gòu)造/賦值（簡化版）
    WeakPtr(WeakPtr<T>&&) = delete;
    WeakPtr<T>& operator=(WeakPtr<T>&&) = delete;
    // 友元聲明：讓SharedPtr訪問WeakPtr的私有成員
    friend class SharedPtr<T>;
};
// 補(bǔ)充SharedPtr的擴(kuò)展（支持WeakPtr）
template <typename T>
class SharedPtr {
private:
    T* ptr;
    int* use_count;
    int* weak_count; // 新增弱引用計數(shù)
    mutex* mtx;
    void release() {
        lock_guard<mutex> lock(*mtx);
        if (--(*use_count) == 0) {
            delete ptr;
            ptr = nullptr;
        }
        // 弱引用計數(shù)處理移交給WeakPtr
    }
    // 供WeakPtr::lock()調(diào)用的私有構(gòu)造函數(shù)
    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:
    // 原有構(gòu)造函數(shù)擴(kuò)展弱引用計數(shù)
    SharedPtr(T* p = nullptr) : ptr(p) {
        try {
            use_count = new int(1);
            weak_count = new int(0); // 初始弱引用計數(shù)為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; }
    // 其余方法（拷貝構(gòu)造、賦值、析構(gòu)等）需適配weak_count，此處省略...
    T* get() const { return ptr; }
};