double Divide(int a, int b) {
    if (b == 0)
        throw "Divide by zero condition!"; // 除0拋出異常
    else
        return (double)a / (double)b;
}
void Func() {
    int* array1 = new int[10];
    int* array2 = new int[10]; // 若此處拋異常，array1已無(wú)法釋放
    try {
        int len, time;
        cin >> len >> time;
        cout << Divide(len, time) << endl;
    }
    catch (...) {
        // 捕獲異常后釋放資源，再重新拋出
        cout << "delete []" << array1 << endl;
        cout << "delete []" << array2 << endl;
        delete[] array1;
        delete[] array2;
        throw;
    }
    // 正常流程釋放資源
    cout << "delete []" << array1 << endl;
    delete[] array1;
    cout << "delete []" << array2 << endl;
    delete[] array2;
}
int main() {
    try {
        Func();
    }
    catch (const char* errmsg) {
        cout << errmsg << endl;
    }
    catch (const exception& e) {
        cout << e.what() << endl;
    }
    catch (...) {
        cout << "未知異常" << endl;
    }
    return 0;
}

template<class T>
class SmartPtr {
public:
    // RAII：構(gòu)造時(shí)接管資源
    SmartPtr(T* ptr) : _ptr(ptr) {}
    // 析構(gòu)時(shí)自動(dòng)釋放資源
    ~SmartPtr() {
        cout << "delete[] " << _ptr << endl;
        delete[] _ptr;
    }
    // 重載運(yùn)算符，模擬指針行為
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    T& operator[](size_t i) { return _ptr[i]; }
private:
    T* _ptr; // 管理的資源指針
};

double Divide(int a, int b) {
    if (b == 0)
        throw "Divide by zero condition!";
    else
        return (double)a / (double)b;
}
void Func() {
    // 智能指針管理動(dòng)態(tài)數(shù)組，自動(dòng)釋放
    SmartPtr<int> sp1 = new int[10];
    SmartPtr<int> sp2 = new int[10];
    for (size_t i = 0; i < 10; i++)
        sp1[i] = sp2[i] = i; // 重載[]運(yùn)算符，直接訪(fǎng)問(wèn)
    int len, time;
    cin >> len >> time;
    cout << Divide(len, time) << endl;
}
int main() {
    try {
        Func();
    }
    catch (const char* errmsg) {
        cout << errmsg << endl;
    }
    catch (const exception& e) {
        cout << e.what() << endl;
    }
    catch (...) {
        cout << "未知異常" << endl;
    }
    return 0;
}

struct Date {
    int _year;
    int _month;
    int _day;
    Date(int year = 1, int month = 1, int day = 1)
        : _year(year), _month(month), _day(day) {}
    ~Date() {
        cout << "~Date()" << endl;
    }
};

int main() {
    auto_ptr<Date> ap1(new Date);
    auto_ptr<Date> ap2(ap1); // 拷貝后，ap1的資源所有權(quán)轉(zhuǎn)移給ap2
    // ap1->_year++; // 錯(cuò)誤：ap1已懸空，空指針訪(fǎng)問(wèn)
    return 0;
}

int main() {
    unique_ptr<Date> up1(new Date);
    // unique_ptr<Date> up2(up1); // 錯(cuò)誤：禁止拷貝
    unique_ptr<Date> up3(move(up1)); // 支持移動(dòng)，up1懸空
    return 0;
}

int main() {
    shared_ptr<Date> sp1(new Date);
    shared_ptr<Date> sp2(sp1); // 拷貝，引用計(jì)數(shù)變?yōu)?
    shared_ptr<Date> sp3(sp2); // 拷貝，引用計(jì)數(shù)變?yōu)?
    cout << sp1.use_count() << endl; // 輸出3：查看引用計(jì)數(shù)
    sp1->_year++; // 重載->，直接訪(fǎng)問(wèn)成員
    cout << sp1->_year << endl; // 輸出2
    cout << sp2->_year << endl; // 輸出2（共享同一資源）
    cout << sp3->_year << endl; // 輸出2
    shared_ptr<Date> sp4(move(sp1)); // 移動(dòng)，sp1懸空
    return 0;
}

int main() {
    // 特化版本，析構(gòu)時(shí)自動(dòng)調(diào)用delete[]
    unique_ptr<Date[]> up1(new Date[5]);
    shared_ptr<Date[]> sp1(new Date[5]);
    return 0;
}

// 1. 函數(shù)指針刪除器
template<class T>
void DeleteArrayFunc(T* ptr) {
    delete[] ptr;
}
// 2. 仿函數(shù)刪除器
template<class T>
class DeleteArray {
public:
    void operator()(T* ptr) {
        delete[] ptr;
    }
};
// 3. 文件句柄刪除器（仿函數(shù)）
class Fclose {
public:
    void operator()(FILE* ptr) {
        cout << "fclose:" << ptr << endl;
        fclose(ptr);
    }
};
int main() {
    // 仿函數(shù)作為刪除器（unique_ptr模板參數(shù)指定，shared_ptr構(gòu)造函數(shù)傳入）
    unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]);
    shared_ptr<Date> sp2(new Date[5], DeleteArray<Date>());
    // 函數(shù)指針作為刪除器
    unique_ptr<Date, void(*)(Date*)> up3(new Date[5], DeleteArrayFunc<Date>);
    shared_ptr<Date> sp3(new Date[5], DeleteArrayFunc<Date>);
    // lambda表達(dá)式作為刪除器
    auto delArrOBJ = [](Date* ptr) { delete[] ptr; };
    unique_ptr<Date, decltype(delArrOBJ)> up4(new Date[5], delArrOBJ);
    shared_ptr<Date> sp4(new Date[5], delArrOBJ);
    // 管理文件句柄
    shared_ptr<FILE> sp5(fopen("Test.cpp", "r"), Fclose());
    shared_ptr<FILE> sp6(fopen("Test.cpp", "r"), [](FILE* ptr) {
        cout << "fclose:" << ptr << endl;
        fclose(ptr);
    });
    return 0;
}

int main() {
    shared_ptr<Date> sp2 = make_shared<Date>(2024, 9, 11); // 直接初始化日期
    auto sp3 = make_shared<Date>(2024, 9, 11); // 自動(dòng)推導(dǎo)類(lèi)型
    return 0;
}

int main() {
    shared_ptr<Date> sp1(new Date(2024, 9, 11));
    shared_ptr<Date> sp4;
    if (sp1) // 等價(jià)于sp1.operator bool()，管理資源返回true
        cout << "sp1 is not nullptr" << endl;
    if (!sp4) // 未管理資源返回false
        cout << "sp4 is nullptr" << endl;
    return 0;
}

int main() {
    // 錯(cuò)誤：explicit構(gòu)造禁止隱式轉(zhuǎn)換
    // shared_ptr<Date> sp5 = new Date(2024, 9, 11);
    // unique_ptr<Date> sp6 = new Date(2024, 9, 11);
    return 0;
}

namespace zephyr {
    template<class T>
    class auto_ptr {
    public:
        auto_ptr(T* ptr) : _ptr(ptr) {}
        // 拷貝構(gòu)造：轉(zhuǎn)移所有權(quán)
        auto_ptr(auto_ptr<T>& sp) : _ptr(sp._ptr) {
            sp._ptr = nullptr; // 原對(duì)象懸空
        }
        // 賦值運(yùn)算符：轉(zhuǎn)移所有權(quán)
        auto_ptr<T>& operator=(auto_ptr<T>& ap) {
            if (this != &ap) { // 避免自賦值
                if (_ptr)
                    delete _ptr; // 釋放當(dāng)前資源
                _ptr = ap._ptr; // 轉(zhuǎn)移資源
                ap._ptr = nullptr; // 原對(duì)象懸空
            }
            return *this;
        }
        // 析構(gòu)釋放資源
        ~auto_ptr() {
            if (_ptr) {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
            }
        }
        // 模擬指針行為
        T& operator*() { return *_ptr; }
        T* operator->() { return _ptr; }
    private:
        T* _ptr;
    };
}

namespace zephyr {
    template<class T>
    class unique_ptr {
    public:
        explicit unique_ptr(T* ptr) : _ptr(ptr) {}
        // 移動(dòng)構(gòu)造：轉(zhuǎn)移資源所有權(quán)
        unique_ptr(unique_ptr<T>&& sp) : _ptr(sp._ptr) {
            sp._ptr = nullptr;
        }
        // 移動(dòng)賦值：轉(zhuǎn)移資源所有權(quán)
        unique_ptr<T>& operator=(unique_ptr<T>&& sp) {
            if (_ptr)
                delete _ptr;
            _ptr = sp._ptr;
            sp._ptr = nullptr;
            return *this;
        }
        // 析構(gòu)釋放資源
        ~unique_ptr() {
            if (_ptr) {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
            }
        }
        // 模擬指針行為
        T& operator*() { return *_ptr; }
        T* operator->() { return _ptr; }
        // 禁止拷貝：刪除拷貝構(gòu)造和賦值運(yùn)算符
        unique_ptr(const unique_ptr<T>& sp) = delete;
        unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;
    private:
        T* _ptr;
    };
}

namespace zephyr {
    template<class T>
    class shared_ptr {
    public:
        // 構(gòu)造：初始化資源和引用計(jì)數(shù)（計(jì)數(shù)初始為1）
        explicit shared_ptr(T* ptr = nullptr)
            : _ptr(ptr)
            , _pcount(new int(1))
            , _del([](T* ptr) { delete ptr; }) {} // 默認(rèn)刪除器
        // 帶自定義刪除器的構(gòu)造
        template<class D>
        shared_ptr(T* ptr, D del)
            : _ptr(ptr)
            , _pcount(new int(1))
            , _del(del) {}
        // 拷貝構(gòu)造：共享資源，引用計(jì)數(shù)+1
        shared_ptr(const shared_ptr<T>& sp)
            : _ptr(sp._ptr)
            , _pcount(sp._pcount)
            , _del(sp._del) {
            ++(*_pcount);
        }
        // 賦值運(yùn)算符：釋放當(dāng)前資源，共享新資源
        shared_ptr<T>& operator=(const shared_ptr<T>& sp) {
            if (_ptr != sp._ptr) { // 避免自賦值
                release(); // 釋放當(dāng)前資源（計(jì)數(shù)-1，為0則刪除）
                _ptr = sp._ptr;
                _pcount = sp._pcount;
                _del = sp._del;
                ++(*_pcount); // 新資源計(jì)數(shù)+1
            }
            return *this;
        }
        // 釋放資源邏輯
        void release() {
            if (--(*_pcount) == 0) { // 計(jì)數(shù)為0，釋放資源和計(jì)數(shù)變量
                _del(_ptr); // 調(diào)用刪除器
                delete _pcount;
                _ptr = nullptr;
                _pcount = nullptr;
            }
        }
        // 析構(gòu)：調(diào)用release釋放資源
        ~shared_ptr() {
            release();
        }
        // 模擬指針行為
        T& operator*() { return *_ptr; }
        T* operator->() { return _ptr; }
        // 實(shí)用接口
        T* get() const { return _ptr; } // 獲取原生指針
        int use_count() const { return *_pcount; } // 獲取引用計(jì)數(shù)
    private:
        T* _ptr; // 管理的資源指針
        int* _pcount; // 引用計(jì)數(shù)（堆上分配，支持共享）
        function<void(T*)> _del; // 自定義刪除器
    };
}

namespace zephyr {
    template<class T>
    class weak_ptr {
    public:
        weak_ptr() : _ptr(nullptr) {}
        // 僅支持通過(guò)shared_ptr構(gòu)造/賦值，不增加引用計(jì)數(shù)
        weak_ptr(const shared_ptr<T>& sp) : _ptr(sp.get()) {}
        weak_ptr<T>& operator=(const shared_ptr<T>& sp) {
            _ptr = sp.get();
            return *this;
        }
    private:
        T* _ptr; // 僅存儲(chǔ)資源指針，不參與管理
    };
}

struct ListNode {
    int _data;
    shared_ptr<ListNode> _next; // 共享下一個(gè)節(jié)點(diǎn)
    shared_ptr<ListNode> _prev; // 共享上一個(gè)節(jié)點(diǎn)
    ~ListNode() {
        cout << "~ListNode()" << endl; // 循環(huán)引用時(shí)不會(huì)執(zhí)行
    }
};
int main() {
    shared_ptr<ListNode> n1(new ListNode);
    shared_ptr<ListNode> n2(new ListNode);
    cout << n1.use_count() << endl; // 輸出1
    cout << n2.use_count() << endl; // 輸出1
    n1->_next = n2; // n2的引用計(jì)數(shù)變?yōu)?
    n2->_prev = n1; // n1的引用計(jì)數(shù)變?yōu)?
    cout << n1.use_count() << endl; // 輸出2
    cout << n2.use_count() << endl; // 輸出2
    // 析構(gòu)n1和n2時(shí)，引用計(jì)數(shù)均變?yōu)?，無(wú)法歸零，資源泄漏
    return 0;
}

struct ListNode {
    int _data;
    weak_ptr<ListNode> _next; // 改為weak_ptr
    weak_ptr<ListNode> _prev; // 改為weak_ptr
    ~ListNode() {
        cout << "~ListNode()" << endl; // 正常執(zhí)行
    }
};
int main() {
    shared_ptr<ListNode> n1(new ListNode);
    shared_ptr<ListNode> n2(new ListNode);
    n1->_next = n2; // weak_ptr不增加n2的引用計(jì)數(shù)（仍為1）
    n2->_prev = n1; // weak_ptr不增加n1的引用計(jì)數(shù)（仍為1）
    // 析構(gòu)n1和n2時(shí)，引用計(jì)數(shù)均變?yōu)?，資源正常釋放
    return 0;
}

int main() {
    shared_ptr<string> sp1(new string("111111"));
    shared_ptr<string> sp2(sp1);
    weak_ptr<string> wp = sp1;
    cout << wp.expired() << endl; // 輸出0：資源未過(guò)期
    cout << wp.use_count() << endl; // 輸出2：獲取引用計(jì)數(shù)
    // sp1和sp2轉(zhuǎn)移資源，原資源釋放
    sp1 = make_shared<string>("222222");
    sp2 = make_shared<string>("333333");
    cout << wp.expired() << endl; // 輸出1：資源已過(guò)期
    cout << wp.use_count() << endl; // 輸出0
    // 重新綁定資源
    wp = sp1;
    auto sp3 = wp.lock(); // 資源有效時(shí)，返回非空shared_ptr
    if (sp3) {
        *sp3 += "###";
        cout << *sp1 << endl; // 輸出"222222###"
    }
    return 0;
}

struct AA {
    int _a1 = 0;
    int _a2 = 0;
    ~AA() {
        cout << "~AA()" << endl;
    }
};
int main() {
    zephyr::shared_ptr<AA> p(new AA);
    const size_t n = 100000;
    mutex mtx;
    // 多線(xiàn)程拷貝智能指針，修改資源對(duì)象
    auto func = [&]() {
        for (size_t i = 0; i < n; ++i) {
            zephyr::shared_ptr<AA> copy(p); // 拷貝時(shí)修改引用計(jì)數(shù)（線(xiàn)程不安全）
            unique_lock<mutex> lk(mtx); // 資源對(duì)象加鎖，保證線(xiàn)程安全
            copy->_a1++;
            copy->_a2++;
        }
    };
    thread t1(func);
    thread t2(func);
    t1.join();
    t2.join();
    cout << p->_a1 << endl; // 可能小于200000（計(jì)數(shù)競(jìng)爭(zhēng)導(dǎo)致部分操作失效）
    cout << p->_a2 << endl;
    cout << p.use_count() << endl;
    return 0;
}

namespace zephyr {
    template<class T>
    class shared_ptr {
    private:
        // 其他成員不變，僅修改引用計(jì)數(shù)類(lèi)型
        atomic<int>* _pcount; // 原子類(lèi)型，保證線(xiàn)程安全
    };
}

int main() {
    // 分配1G內(nèi)存未釋放，但程序立即結(jié)束，進(jìn)程退出時(shí)系統(tǒng)回收資源
    char* ptr = new char[1024 * 1024 * 1024];
    cout << (void*)ptr << endl;
    return 0;
}

template<class T>
class MySmartPtr {
public:
    // 未用 explicit 修飾的構(gòu)造函數(shù)（危險(xiǎn)！）
    MySmartPtr(T* ptr) : _ptr(ptr) {} 
    ~MySmartPtr() {
        delete _ptr; // 析構(gòu)時(shí)釋放內(nèi)存
        cout << "內(nèi)存已釋放" << endl;
    }
    T& operator*() { return *_ptr; }
private:
    T* _ptr;
};

// 函數(shù)參數(shù)為智能指針類(lèi)型
void UseResource(MySmartPtr<int> sp) {
    cout << "使用資源：" << *sp << endl;
}
int main() {
    int* raw_ptr = new int(100); // 普通指針
    // 隱式轉(zhuǎn)換：raw_ptr 被自動(dòng)轉(zhuǎn)換為 MySmartPtr<int> 對(duì)象
    UseResource(raw_ptr); 
    // 危險(xiǎn)！此時(shí) raw_ptr 指向的內(nèi)存已被 UseResource 中智能指針的析構(gòu)函數(shù)釋放
    cout << *raw_ptr << endl; // 訪(fǎng)問(wèn)已釋放內(nèi)存（未定義行為，可能崩潰）
    delete raw_ptr; // 重復(fù)釋放（必然崩潰）
    return 0;
}

#include <memory>
#include <cstdio>
using namespace std;
int main() {
    // 管理 FILE* 資源，自定義刪除器用 fclose 釋放
    FILE* fp = fopen("test.txt", "w");
    shared_ptr<FILE> sp(fp, [](FILE* p) { 
        fclose(p); 
        cout << "文件已關(guān)閉" << endl; 
    }); 
    return 0;
}

unique_ptr<Date, void(*)(Date*)> up3;

// 錯(cuò)誤示例：只指定類(lèi)型，未傳入具體刪除器實(shí)例
unique_ptr<Date, void(*)(Date*)> up3(new Date[5]); 

// 仿函數(shù)刪除器：
unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]); 
unique_ptr<Date, DeleteArray<Date>> up2(new Date[5], DeleteArray<Date>()); 
// （省略時(shí)其實(shí)是隱式構(gòu)造了一個(gè)實(shí)例，等價(jià)于上面的寫(xiě)法）
// lambda刪除器：傳入了delArrOBJ這個(gè)實(shí)例
unique_ptr<Date, decltype(delArrOBJ)> up4(new Date[5], delArrOBJ);
//lambda表達(dá)式的特殊之處在于無(wú)法用推導(dǎo)出的類(lèi)型來(lái)隱式構(gòu)造一個(gè)實(shí)例
//lambda 閉包類(lèi)型的構(gòu)造函數(shù)是 “受限的”，因?yàn)殚]包類(lèi)型沒(méi)有默認(rèn)構(gòu)造函數(shù)，且用戶(hù)無(wú)法手動(dòng)調(diào)用其構(gòu)造函數(shù)