C++异常处理完全指南(最新推荐)

// C语言风格：用返回值表示错误
int Div(int a, int b, int* result) {
    if (b == 0) {
        return -1;  // 除0错误
    }
    *result = a / b;
    return 0;  // 成功
}
int main() {
    int result;
    int ret = Div(10, 0, &result);
    if (ret == -1) {
        printf("除0错误！\n");
    } else if (ret == -2) {
        printf("溢出错误！\n");
    }
    // 每多一种错误，就多一个if...查表过程非常繁琐
}

#include <iostream>
#include <string>
using namespace std;
double Divide(int a, int b) {
    if (b == 0) {
        string s("Divide by zero condition!");
        throw s;  // 抛出一个异常对象，函数到此为止，后面代码不再执行
    }
    return (double)a / (double)b;
}
int main() {
    try {
        cout << Divide(10, 0) << endl;  // 受监控的代码块
    } catch (const string& errmsg) {     // 类型匹配的异常处理
        cout << "捕获到异常：" << errmsg << endl;
    } catch (...) {                       // 兜底：捕获任意类型
        cout << "未知异常" << endl;
    }
    return 0;
}

void Func() {
    int len, time;
    cin >> len >> time;
    try {
        cout << Divide(len, time) << endl;
    } catch (const char* errmsg) {
        cout << errmsg << endl;
    }
    cout << __FUNCTION__ << ":" << __LINE__ << "行执行" << endl;
}
int main() {
    while (1) {
        try {
            Func();
        } catch (const string& errmsg) {  // Func没catch string类型，继续往外找
            cout << errmsg << endl;
        } catch (...) {
            cout << "未知异常" << endl;
        }
    }
    return 0;
}

调用链： main → Func → Divide
                         │
                      throw string ← 异常从这里抛出
                         │
                    ┌────┘
                    ▼
              Func 退出了吗？退了！
              Func 的catch匹配吗？不匹配！
                    │
               ┌────┘
               ▼
         main 的catch匹配吗？匹配！→ 在这里处理

// 抛出 string
throw string("hello");
// 按顺序匹配，第一个匹配的就进去
catch (int x)           { }  // 不匹配
catch (const string& s) { }  // 匹配！进入这里
catch (string s)        { }  // 虽然也匹配，但前面已经进了
catch (...)             { }  // 兜底

catch (...) {
    // 捕获一切，但你不知道具体是什么
    cout << "未知异常" << endl;
}

#include <iostream>
#include <string>
#include <thread>
using namespace std;
// ==================== 异常基类 ====================
class Exception {
public:
    Exception(const string& errmsg, int id)
        : _errmsg(errmsg), _id(id) {}
    virtual string what() const {
        return _errmsg;
    }
    int getid() const {
        return _id;
    }
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) {}
    virtual string what() const {
        string str = "SqlException:";
        str += _errmsg;
        str += "->";
        str += _sql;       // 附上出错的SQL语句
        return str;
    }
private:
    const string _sql;
};
// ==================== 缓存模块异常 ====================
class CacheException : public Exception {
public:
    CacheException(const string& errmsg, int id)
        : Exception(errmsg, id) {}
    virtual string what() const {
        string str = "CacheException:";
        str += _errmsg;
        return str;
    }
};
// ==================== HTTP 模块异常 ====================
class HttpException : public Exception {
public:
    HttpException(const string& errmsg, int id, const string& type)
        : Exception(errmsg, id), _type(type) {}
    virtual string what() const {
        string str = "HttpException:";
        str += _type;       // GET/POST/PUT
        str += ":";
        str += _errmsg;
        return str;
    }
private:
    const string _type;
};

void SQLMgr() {
    if (rand() % 7 == 0) {
        throw SqlException("权限不足", 100, "select * from name = '张三'");
    }
    cout << "SQLMgr 调用成功" << endl;
}
void CacheMgr() {
    if (rand() % 5 == 0) {
        throw CacheException("权限不足", 100);
    } else if (rand() % 6 == 0) {
        throw CacheException("数据不存在", 101);
    }
    cout << "CacheMgr 调用成功" << endl;
    SQLMgr();   // Cache里面还要调SQL
}
void HttpServer() {
    if (rand() % 3 == 0) {
        throw HttpException("请求资源不存在", 100, "get");
    } else if (rand() % 4 == 0) {
        throw HttpException("权限不足", 101, "post");
    }
    cout << "HttpServer 调用成功" << endl;
    CacheMgr();  // HTTP里面调缓存，缓存里面还调SQL
}

int main() {
    srand(time(0));
    while (1) {
        this_thread::sleep_for(chrono::seconds(1));
        try {
            HttpServer();
        }
        catch (const Exception& e) {  // 只catch基类引用！
            // 多态调用——根据实际对象类型调用对应的what()
            cout << e.what() << endl;
        }
        catch (...) {
            cout << "Unknown Exception" << endl;
        }
    }
    return 0;
}

catch (const Exception& e) {
    if (e.getid() == 102) {
        // 能处理：网络问题，重试
    } else {
        throw;  // 重新抛出当前捕获的异常对象
    }
}

// 底层发送函数：可能抛异常
void _SendMsg(const string& s) {
    if (rand() % 2 == 0) {
        throw HttpException("网络不稳定，发送失败", 102, "put");     // 可重试
    } else if (rand() % 7 == 0) {
        throw HttpException("你已经不是对方的好友，发送失败", 103, "put");  // 不可重试
    }
    cout << "发送成功" << endl;
}
// 上层：带重试逻辑
void SendMsg(const string& s) {
    for (size_t i = 0; i < 4; i++) {     // 最多重试3次
        try {
            _SendMsg(s);
            break;                         // 发送成功，退出循环
        }
        catch (const Exception& e) {
            if (e.getid() == 102) {       // 102号：网络问题，可重试
                if (i == 3) {
                    throw;                 // 重试3次都失败，认命，往上抛
                }
                cout << "开始第" << i + 1 << "次重试" << endl;
            } else {
                throw;                     // 不是网络问题，不重试，直接往上抛
            }
        }
    }
}
// 最上层：展示结果给用户
int main() {
    srand(time(0));
    string str;
    while (cin >> str) {
        try {
            SendMsg(str);
        }
        catch (const Exception& e) {
            cout << e.what() << endl << endl;
        }
        catch (...) {
            cout << "Unknown Exception" << endl;
        }
    }
    return 0;
}

void Func() {
    int* array = new int[10];   // ① 申请堆内存
    int len, time;
    cin >> len >> time;
    cout << Divide(len, time) << endl;  // ② 如果这里抛异常了……
    delete[] array;             // ③ 这行根本执行不到！
}

void Func() {
    int* array = new int[10];
    try {
        int len, time;
        cin >> len >> time;
        cout << Divide(len, time) << endl;
    }
    catch (...) {
        // 不管什么异常，先释放资源
        delete[] array;
        throw;  // 再把异常原样抛出去，让上层处理
    }
    delete[] array;
}

~MyClass() {
    // 析构函数要释放10个资源
    // 如果释放到第5个时抛异常，后面5个就泄漏了
    // 所以析构函数内部要做好try/catch，别让异常逃出去
    try {
        // 释放资源
    } catch (...) {
        // 吞掉异常或记录日志，但不往外抛
    }
}

// C++98 风格：函数后面写 throw(可能抛的类型)
void* operator new (size_t size) throw (std::bad_alloc);   // 可能抛 bad_alloc
void* operator delete (void* ptr) throw();                   // 不抛异常
// 过于复杂，实践中没人用，C++11 废弃了

// C++11 简洁版
size_type size() const noexcept;           // 承诺不抛异常
iterator begin() noexcept;                 // 承诺不抛异常

#include <list>
double Divide(int a, int b) {
    if (b == 0) throw "Division by zero condition!";
    return (double)a / (double)b;
}
int main() {
    int i = 0;
    // noexcept(表达式) 在编译期判断表达式是否会抛异常
    cout << noexcept(Divide(1, 2)) << endl;  // 0 (false) —— 可能抛异常
    cout << noexcept(Divide(1, 0)) << endl;  // 0 (false) —— 可能抛异常
    cout << noexcept(++i)        << endl;  // 1 (true)  —— ++i 不抛异常
    list<int> lt;
    cout << noexcept(lt.begin()) << endl;    // 1 (true)  —— begin() 声明了 noexcept
    return 0;
}

std::exception              ← 基类，virtual const char* what()
├── std::logic_error        ← 逻辑错误（可在编译期检测）
│   ├── std::invalid_argument
│   ├── std::out_of_range
│   └── std::length_error
├── std::runtime_error      ← 运行时错误
│   ├── std::overflow_error
│   ├── std::range_error
│   └── std::system_error
└── std::bad_alloc          ← new 失败

int main() {
    try {
        // 你的程序
    }
    catch (const exception& e) {
        cout << "标准库异常：" << e.what() << endl;
    }
    catch (...) {
        cout << "未知异常" << endl;
    }
    return 0;
}