// C語言風格：錯誤碼層層傳遞的冗余
int ConnectSql() {
    if (權限不足) return 1;
    if (連接失敗) return 2;
    return 0;
}
int ServerStart() {
    int ret = ConnectSql();
    if (ret != 0) return ret; // 手動傳遞錯誤碼
    int fd = socket();
    if (fd < 0) return errno; // 再傳遞系統(tǒng)錯誤碼
}
int main() {
    int ret = ServerStart();
    if (ret != 0) {
        // 還需根據(jù)錯誤碼查表判斷具體問題
        printf("錯誤碼：%d\n", ret);
    }
    return 0;
}

try {
    // 可能拋出異常的“保護代碼”
    函數(shù)調用或危險操作;
} catch (異常類型1 e1) {
    // 處理類型1的異常
} catch (異常類型2 e2) {
    // 處理類型2的異常
} catch (...) {
    // 捕獲所有未匹配的異常（兜底，避免程序崩潰）
}

#include <iostream>
using namespace std;
// 發(fā)生除0時拋出異常
double Division(int a, int b) {
    if (b == 0) {
        // 拋出字符串異常（也可拋自定義對象）
        throw "Division by zero condition!";
    }
    return (double)a / b;
}
void Func() {
    int len, time;
    cin >> len >> time;
    // 若Division拋異常，直接跳轉到catch
    cout << Division(len, time) << endl;
}
int main() {
    try {
        Func();
    } catch (const char* errmsg) {
        // 捕獲字符串類型異常，打印錯誤信息
        cout << "錯誤：" << errmsg << endl;
    } catch (...) {
        // 兜底：捕獲所有其他類型異常
        cout << "未知異常" << endl;
    }
    return 0;
}

void Func() {
    // 申請資源（若拋異常需釋放）
    int* array = new int[10];
    try {
        int len, time;
        cin >> len >> time;
        cout << Division(len, time) << endl;
    } catch (...) {
        // 先釋放資源，再重新拋出異常
        cout << "釋放array：" << array << endl;
        delete[] array;
        throw; // 移交外層處理
    }
    // 正常執(zhí)行時釋放資源
    delete[] array;
}

#include <string>
using namespace std;
// 異?；?
class Exception {
public:
    Exception(const string& errmsg, int id) 
        : _errmsg(errmsg), _id(id) {}
    // 虛函數(shù)：支持多態(tài)，子類重寫錯誤信息
    virtual string what() const {
        return _errmsg;
    }
protected:
    string _errmsg; // 錯誤描述
    int _id;        // 錯誤編號（便于定位問題）
};
// SQL異常（派生類）
class SqlException : public Exception {
public:
    SqlException(const string& errmsg, int id, const string& sql)
        : Exception(errmsg, id), _sql(sql) {}
    // 重寫what，添加SQL信息
    virtual string what() const override {
        string str = "SqlException: ";
        str += _errmsg;
        str += " (SQL: ";
        str += _sql;
        str += ")";
        return str;
    }
private:
    string _sql; // 出問題的SQL語句
};
// 緩存異常（派生類）
class CacheException : public Exception {
public:
    CacheException(const string& errmsg, int id)
        : Exception(errmsg, id) {}
    virtual string what() const override {
        return "CacheException: " + _errmsg;
    }
};
// 模擬SQL操作：隨機拋異常
void SQLMgr() {
    srand(time(0));
    if (rand() % 7 == 0) {
        throw SqlException("權限不足", 100, "select * from user where name='張三'");
    }
}
// 模擬緩存操作：隨機拋異常
void CacheMgr() {
    srand(time(0));
    if (rand() % 5 == 0) {
        throw CacheException("數(shù)據(jù)不存在", 101);
    }
    SQLMgr(); // 調用SQL操作
}
int main() {
    while (1) {
        this_thread::sleep_for(chrono::seconds(1));
        try {
            CacheMgr();
            cout << "操作成功" << endl;
        } catch (const Exception& e) {
            // 捕獲基類，統(tǒng)一處理所有異常（多態(tài)生效）
            cout << "捕獲異常：" << e.what() << endl;
        } catch (...) {
            cout << "未知異常" << endl;
        }
    }
    return 0;
}

std::exception
├─ std::bad_alloc（new失敗時拋）
├─ std::bad_cast（dynamic_cast失敗時拋）
├─ std::logic_error（邏輯錯誤，如參數(shù)無效）
│  ├─ std::invalid_argument（無效參數(shù)）
│  └─ std::out_of_range（越界，如vector::at）
└─ std::runtime_error（運行時錯誤）
   └─ std::overflow_error（算術溢出）

#include <vector>
#include <exception>
int main() {
    try {
        vector<int> v(10);
        v.at(10) = 100; // 越界，拋out_of_range
    } catch (const exception& e) {
        // 調用what()獲取錯誤信息
        cout << e.what() << endl; // 輸出：vector::_M_range_check: __n (which is 10) >= this->size() (which is 10)
    }
    return 0;
}

void Func() {
    throw "模擬異常"; // 拋出異常
}
void Test() {
    int* p = new int; // 申請內(nèi)存
    Func();           // 拋異常，執(zhí)行流跳走
    delete p;         // 永遠不會執(zhí)行，內(nèi)存泄漏
}

template<class T>
class SmartPtr {
public:
    // 構造：獲取資源（內(nèi)存）
    SmartPtr(T* ptr = nullptr) : _ptr(ptr) {}
    // 析構：釋放資源（內(nèi)存）
    ~SmartPtr() {
        if (_ptr) {
            delete _ptr;
            cout << "釋放內(nèi)存：" << _ptr << endl;
        }
    }
    // 重載*和->，讓SmartPtr像普通指針一樣使用
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
private:
    T* _ptr; // 管理的資源（內(nèi)存地址）
};
// 測試：即使拋異常，內(nèi)存也會自動釋放
void Test() {
    SmartPtr<int> sp(new int); // 構造：獲取內(nèi)存
    *sp = 10;                  // 像普通指針一樣使用
    throw "模擬異常";           // 拋異常，sp對象銷毀時調用析構
    // 無需手動delete，析構自動釋放
}

#include <memory> // auto_ptr所在頭文件
int main() {
    auto_ptr<int> sp1(new int(10));
    auto_ptr<int> sp2 = sp1; // 管理權轉移：sp1失去資源，sp2擁有資源
    *sp2 = 20; // 正常：sp2擁有資源
    *sp1 = 30; // 崩潰：sp1已懸空（指向nullptr）
    return 0;
}

#include <memory>
int main() {
    // 1. 基本使用
    unique_ptr<int> sp1(new int(10));
    cout << *sp1 << endl; // 10
    // 2. 禁止拷貝和賦值（編譯報錯）
    // unique_ptr<int> sp2 = sp1; // 錯誤：拷貝構造已刪除
    // sp1 = sp2;                // 錯誤：賦值運算符已刪除
    // 3. 移動語義：轉移所有權
    unique_ptr<int> sp2 = std::move(sp1); // 轉移后sp1懸空
    cout << *sp2 << endl; // 10
    // cout << *sp1 << endl; // 崩潰：sp1已懸空
    // 4. 管理數(shù)組（需指定刪除器，或用unique_ptr<int[]>）
    unique_ptr<int[]> sp3(new int[5]); // 專門用于數(shù)組，析構時調用delete[]
    sp3[0] = 1;
    sp3[1] = 2;
    return 0;
}

template<class T>
class shared_ptr {
public:
    // 構造：資源+引用計數(shù)（初始為1）
    shared_ptr(T* ptr = nullptr) 
        : _ptr(ptr), _pRefCount(new int(1)), _pmtx(new mutex) {}
    // 拷貝構造：引用計數(shù)+1
    shared_ptr(const shared_ptr<T>& sp) 
        : _ptr(sp._ptr), _pRefCount(sp._pRefCount), _pmtx(sp._pmtx) {
        AddRef(); // 引用計數(shù)+1（加鎖保證線程安全）
    }
    // 賦值運算符：釋放當前資源，引用新資源
    shared_ptr<T>& operator=(const shared_ptr<T>& sp) {
        if (_ptr != sp._ptr) { // 避免自賦值
            Release(); // 釋放當前資源（引用計數(shù)-1，為0則刪除）
            _ptr = sp._ptr;
            _pRefCount = sp._pRefCount;
            _pmtx = sp._pmtx;
            AddRef(); // 新資源引用計數(shù)+1
        }
        return *this;
    }
    // 析構：引用計數(shù)-1，為0則釋放資源
    ~shared_ptr() {
        Release();
    }
    // 重載*和->
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    // 獲取引用計數(shù)
    int use_count() const { return *_pRefCount; }
private:
    // 引用計數(shù)+1（加鎖，線程安全）
    void AddRef() {
        _pmtx->lock();
        (*_pRefCount)++;
        _pmtx->unlock();
    }
    // 引用計數(shù)-1，為0則釋放資源
    void Release() {
        _pmtx->lock();
        bool needDelete = false;
        if (--(*_pRefCount) == 0) {
            delete _ptr;
            delete _pRefCount;
            needDelete = true;
        }
        _pmtx->unlock();
        if (needDelete) {
            delete _pmtx; // 最后一個對象銷毀時，刪除鎖
        }
    }
private:
    T* _ptr;          // 管理的資源
    int* _pRefCount;  // 引用計數(shù)（指針：所有共享對象共享同一計數(shù)）
    mutex* _pmtx;     // 互斥鎖：保證引用計數(shù)操作線程安全
};

#include <cstdlib> // malloc/free
#include <cstdio>  // FILE/fclose
// 1. 管理malloc分配的內(nèi)存（自定義刪除器）
void FreeFunc(int* ptr) {
    free(ptr);
    cout << "free內(nèi)存：" << ptr << endl;
}
shared_ptr<int> sp1((int*)malloc(4), FreeFunc);
// 2. 管理數(shù)組（用lambda作為刪除器）
shared_ptr<int> sp2(new int[5], [](int* ptr) {
    delete[] ptr;
    cout << "delete[]數(shù)組：" << ptr << endl;
});
// 3. 管理文件句柄
shared_ptr<FILE> sp3(fopen("test.txt", "w"), [](FILE* ptr) {
    fclose(ptr);
    cout << "關閉文件：" << ptr << endl;
});

struct ListNode {
    int _data;
    shared_ptr<ListNode> _prev; // 指向前驅節(jié)點
    shared_ptr<ListNode> _next; // 指向后繼節(jié)點
    ~ListNode() { cout << "~ListNode()" << endl; }
};
int main() {
    shared_ptr<ListNode> node1(new ListNode);
    shared_ptr<ListNode> node2(new ListNode);
    cout << node1.use_count() << endl; // 1
    cout << node2.use_count() << endl; // 1
    node1->_next = node2; // node1的_next引用node2，node2計數(shù)變?yōu)?
    node2->_prev = node1; // node2的_prev引用node1，node1計數(shù)變?yōu)?
    // 析構node1和node2：計數(shù)各減1，變?yōu)?（非0），資源不釋放
    return 0;
}

#include <memory>
struct ListNode {
    int _data;
    weak_ptr<ListNode> _prev;  // 弱引用：不增加計數(shù)
    weak_ptr<ListNode> _next;  // 弱引用：不增加計數(shù)
    ~ListNode() { cout << "~ListNode()" << endl; }
};
int main() {
    shared_ptr<ListNode> node1(new ListNode);
    shared_ptr<ListNode> node2(new ListNode);
    cout << node1.use_count() << endl; // 1
    cout << node2.use_count() << endl; // 1
    node1->_next = node2; // weak_ptr賦值，node2計數(shù)仍為1
    node2->_prev = node1; // weak_ptr賦值，node1計數(shù)仍為1
    // 析構node1和node2：計數(shù)減到0，資源釋放（打印~ListNode()）
    return 0;
}