C++进阶异常处理与智能指针实战指南

// 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; // 再传递系统错误码
}
int main() {
    int ret = ServerStart();
    if (ret != 0) {
        // 还需根据错误码查表判断具体问题
        printf("错误码：%d\n", ret);
    }
    return 0;
}

try {
    // 可能抛出异常的“保护代码”
    函数调用或危险操作;
} catch (异常类型1 e1) {
    // 处理类型1的异常
} catch (异常类型2 e2) {
    // 处理类型2的异常
} catch (...) {
    // 捕获所有未匹配的异常（兜底，避免程序崩溃）
}

#include <iostream>
using namespace std;
// 发生除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; // 移交外层处理
    }
    // 正常执行时释放资源
    delete[] array;
}

#include <string>
using namespace std;
// 异常基类
class Exception {
public:
    Exception(const string& errmsg, int id) 
        : _errmsg(errmsg), _id(id) {}
    // 虚函数：支持多态，子类重写错误信息
    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("数据不存在", 101);
    }
    SQLMgr(); // 调用SQL操作
}
int main() {
    while (1) {
        this_thread::sleep_for(chrono::seconds(1));
        try {
            CacheMgr();
            cout << "操作成功" << endl;
        } catch (const Exception& e) {
            // 捕获基类，统一处理所有异常（多态生效）
            cout << "捕获异常：" << e.what() << endl;
        } catch (...) {
            cout << "未知异常" << endl;
        }
    }
    return 0;
}

std::exception
├─ std::bad_alloc（new失败时抛）
├─ std::bad_cast（dynamic_cast失败时抛）
├─ std::logic_error（逻辑错误，如参数无效）
│  ├─ std::invalid_argument（无效参数）
│  └─ 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; // 申请内存
    Func();           // 抛异常，执行流跳走
    delete p;         // 永远不会执行，内存泄漏
}

template<class T>
class SmartPtr {
public:
    // 构造：获取资源（内存）
    SmartPtr(T* ptr = nullptr) : _ptr(ptr) {}
    // 析构：释放资源（内存）
    ~SmartPtr() {
        if (_ptr) {
            delete _ptr;
            cout << "释放内存：" << _ptr << endl;
        }
    }
    // 重载*和->，让SmartPtr像普通指针一样使用
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
private:
    T* _ptr; // 管理的资源（内存地址）
};
// 测试：即使抛异常，内存也会自动释放
void Test() {
    SmartPtr<int> sp(new int); // 构造：获取内存
    *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. 管理数组（需指定删除器，或用unique_ptr<int[]>）
    unique_ptr<int[]> sp3(new int[5]); // 专门用于数组，析构时调用delete[]
    sp3[0] = 1;
    sp3[1] = 2;
    return 0;
}

template<class T>
class shared_ptr {
public:
    // 构造：资源+引用计数（初始为1）
    shared_ptr(T* ptr = nullptr) 
        : _ptr(ptr), _pRefCount(new int(1)), _pmtx(new mutex) {}
    // 拷贝构造：引用计数+1
    shared_ptr(const shared_ptr<T>& sp) 
        : _ptr(sp._ptr), _pRefCount(sp._pRefCount), _pmtx(sp._pmtx) {
        AddRef(); // 引用计数+1（加锁保证线程安全）
    }
    // 赋值运算符：释放当前资源，引用新资源
    shared_ptr<T>& operator=(const shared_ptr<T>& sp) {
        if (_ptr != sp._ptr) { // 避免自赋值
            Release(); // 释放当前资源（引用计数-1，为0则删除）
            _ptr = sp._ptr;
            _pRefCount = sp._pRefCount;
            _pmtx = sp._pmtx;
            AddRef(); // 新资源引用计数+1
        }
        return *this;
    }
    // 析构：引用计数-1，为0则释放资源
    ~shared_ptr() {
        Release();
    }
    // 重载*和->
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
    // 获取引用计数
    int use_count() const { return *_pRefCount; }
private:
    // 引用计数+1（加锁，线程安全）
    void AddRef() {
        _pmtx->lock();
        (*_pRefCount)++;
        _pmtx->unlock();
    }
    // 引用计数-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;  // 引用计数（指针：所有共享对象共享同一计数）
    mutex* _pmtx;     // 互斥锁：保证引用计数操作线程安全
};

#include <cstdlib> // malloc/free
#include <cstdio>  // FILE/fclose
// 1. 管理malloc分配的内存（自定义删除器）
void FreeFunc(int* ptr) {
    free(ptr);
    cout << "free内存：" << ptr << endl;
}
shared_ptr<int> sp1((int*)malloc(4), FreeFunc);
// 2. 管理数组（用lambda作为删除器）
shared_ptr<int> sp2(new int[5], [](int* ptr) {
    delete[] ptr;
    cout << "delete[]数组：" << 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; // 指向前驱节点
    shared_ptr<ListNode> _next; // 指向后继节点
    ~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计数变为2
    node2->_prev = node1; // node2的_prev引用node1，node1计数变为2
    // 析构node1和node2：计数各减1，变为1（非0），资源不释放
    return 0;
}

#include <memory>
struct ListNode {
    int _data;
    weak_ptr<ListNode> _prev;  // 弱引用：不增加计数
    weak_ptr<ListNode> _next;  // 弱引用：不增加计数
    ~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计数仍为1
    node2->_prev = node1; // weak_ptr赋值，node1计数仍为1
    // 析构node1和node2：计数减到0，资源释放（打印~ListNode()）
    return 0;
}