#include <memory>
#include <iostream>

int main() {
    // 1. 創(chuàng)建：優(yōu)先用make_unique（C++14引入，更安全高效）
    std::unique_ptr<int> p1 = std::make_unique<int>(42); 
    // 等價于：std::unique_ptr<int> p1(new int(42));

    // 2. 訪問對象：用*或->
    std::cout << *p1 << std::endl; // 輸出42

    // 3. 移動所有權(quán)（不可拷貝）
    std::unique_ptr<int> p2 = std::move(p1); // p1失去所有權(quán)，變?yōu)閚ullptr
    if (!p1) std::cout << "p1 is null" << std::endl;

    // 4. 數(shù)組版本
    std::unique_ptr<int[]> arr = std::make_unique<int[]>(3);
    arr[0] = 1; arr[1] = 2; arr[2] = 3;

    // 5. 釋放所有權(quán)：release()返回裸指針，不再管理
    int* raw = p2.release();
    delete raw; // 需手動釋放（不推薦，盡量用智能指針全程管理）

    // 6. 重置：reset()釋放當(dāng)前對象，可選新對象
    p2.reset(new int(100)); // 先釋放原對象（若有），再管理新對象
    p2.reset(); // 釋放對象，變?yōu)閚ullptr

    return 0;
}

#include <cstdio>
#include <memory>

// 自定義刪除器：關(guān)閉文件
struct FileDeleter {
    void operator()(FILE* fp) const {
        if (fp) std::fclose(fp);
    }
};

int main() {
    // 用自定義刪除器創(chuàng)建unique_ptr
    std::unique_ptr<FILE, FileDeleter> fp(std::fopen("test.txt", "w"));
    if (fp) std::fputs("hello", fp.get()); // get()返回裸指針
    // 離開作用域時，自動調(diào)用FileDeleter釋放文件
    return 0;
}

#include <memory>
#include <iostream>

int main() {
    // 1. 創(chuàng)建：優(yōu)先用make_shared（更高效）
    auto p1 = std::make_shared<int>(42); 
    std::cout << "use_count: " << p1.use_count() << std::endl; // 輸出1

    // 2. 共享所有權(quán)：拷貝時計數(shù)+1
    auto p2 = p1; 
    std::cout << "use_count: " << p1.use_count() << std::endl; // 輸出2

    // 3. 釋放所有權(quán)：reset()減少計數(shù)
    p1.reset(); 
    std::cout << "use_count after p1.reset(): " << p2.use_count() << std::endl; // 輸出1

    // 4. 自定義刪除器（管理動態(tài)數(shù)組）
    auto arr = std::shared_ptr<int>(new int[3], [](int* p) { delete[] p; });
    arr.get()[0] = 1; // 訪問數(shù)組元素

    return 0;
}

#include <memory>

struct A { std::shared_ptr<B> b; };
struct B { std::shared_ptr<A> a; };

int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->b = b; // A的b指向B，B的計數(shù)+1（變?yōu)?）
    b->a = a; // B的a指向A，A的計數(shù)+1（變?yōu)?）
    // 離開作用域時，a和b的計數(shù)各減1（變?yōu)?），無法釋放！
    return 0;
}

struct A { std::weak_ptr<B> b; }; // 弱引用，不增加B的計數(shù)
struct B { std::weak_ptr<A> a; }; // 弱引用，不增加A的計數(shù)

int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->b = b; // B的計數(shù)仍為1（weak_ptr不增加）
    b->a = a; // A的計數(shù)仍為1（weak_ptr不增加）
    // 離開作用域時，a和b的計數(shù)各減1（變?yōu)?），正常釋放！
    return 0;
}

#include <memory>
#include <iostream>

int main() {
    auto sp = std::make_shared<int>(42);
    std::weak_ptr<int> wp = sp; // 弱引用指向sp的對象

    // 1. 檢查有效性
    if (!wp.expired()) {
        std::cout << "Object exists" << std::endl;
    }

    // 2. 訪問對象：lock()獲取shared_ptr
    auto locked_sp = wp.lock();
    if (locked_sp) {
        std::cout << *locked_sp << std::endl; // 輸出42
    }

    // 3. 釋放原對象
    sp.reset();
    if (wp.expired()) {
        std::cout << "Object has been released" << std::endl;
    }

    return 0;
}