【C++进阶篇】走进C++的异常世界：从抛出到捕获的全方位解读

#include <iostream>
#include <stdexcept>  // 包含标准异常类

using namespace std;

// 自定义异常类（继承自exception）
class NegativeValueError : public exception {
public:
    const char* what() const noexcept override {
        return "错误：不允许负值参数";
    }
};

// 可能抛出异常的函数
double calculate_sqrt(double value) {
    if (value < 0) {
        throw NegativeValueError();  // 抛出自定义异常
    }
    return sqrt(value);
}

// 另一个可能抛出异常的函数
int divide_numbers(int a, int b) {
    if (b == 0) {
        throw runtime_error("错误：除数不能为零");  // 抛出标准异常
    }
    if (a % b != 0) {
        throw "结果不是整数";  // 抛出原始字符串（不推荐，仅作演示）
    }
    return a / b;
}

int main() {
    try {
        // 测试平方根计算
        cout << "计算sqrt(4): ";
        cout << calculate_sqrt(4) << endl;
        
        cout << "计算sqrt(-1): ";
        cout << calculate_sqrt(-1) << endl;  // 这里会抛出异常

        // 测试除法运算
        cout << "\n10 / 2 = ";
        cout << divide_numbers(10, 2) << endl;
        
        cout << "5 / 0 = ";
        cout << divide_numbers(5, 0) << endl;  // 这里会抛出异常
        
        cout << "7 / 3 = ";
        cout << divide_numbers(7, 3) << endl;  // 这里会抛出异常

    } catch (const NegativeValueError& e) {  // 捕获自定义异常
        cerr << "捕获到自定义异常: " << e.what() << endl;
    } catch (const runtime_error& e) {       // 捕获标准异常
        cerr << "捕获到运行时错误: " << e.what() << endl;
    } catch (const char* msg) {              // 捕获原始字符串异常
        cerr << "捕获到字符串异常: " << msg << endl;
    } catch (...) {                          // 捕获所有其他异常
        cerr << "捕获到未知异常" << endl;
    }

    cout << "\n程序继续执行..." << endl;
    return 0;
}

#include <iostream>
using namespace std;

class MyClass {
public:
    MyClass(int id) : id_(id) {
        cout << "对象 " << id_ << " 构造" << endl;
    }
    ~MyClass() {
        cout << "对象 " << id_ << " 析构" << endl;
    }
private:
    int id_;
};

void func3() {
    MyClass obj3(3);  // 局部对象
    throw runtime_error("异常发生！");
}

void func2() {
    MyClass obj2(2);  // 局部对象
    func3();
}

void func1() {
    MyClass obj1(1);  // 局部对象
    func2();
}

int main() {
    try {
        func1();
    } catch (const exception& e) {
        cerr << "捕获异常: " << e.what() << endl;
    }
    cout << "程序继续执行..." << endl;
    return 0;
}

#include <iostream>
#include <stdexcept>
using namespace std;

// 派生类转基类示例
class Base { virtual void foo() {} };
class Derived : public Base {};

// 自定义异常类
class MyException : public exception {
public:
    const char* what() const noexcept override {
        return "自定义异常：派生类转基类失败";
    }
};

int main() {
    try {
        // 类型转换示例 1：非常量转常量
        int num = 42;
        const int& cnum = num;

        // 类型转换示例 2：数组转指针
        int arr[5] = { 1,2,3,4,5 };
        int* ptr = arr;

        // 类型转换示例 3：函数转指针
        void (*funcPtr)(int) = [](int x) { cout << "Lambda: " << x << endl; };
        funcPtr(10);

        // 类型转换示例 4：派生类转基类
        Derived d;
        Base* b = &d;

        // 异常抛出示例
        if (b == nullptr) throw MyException();
        throw runtime_error("运行时错误：空指针异常");

    }
    catch (const MyException& e) {  // 精确捕获
        cerr << "捕获特定异常: " << e.what() << endl;
    }
    catch (const exception& e) {    // 标准异常捕获
        cerr << "捕获标准异常: " << e.what() << endl;
    }
    catch (...) {                   // 兜底捕获（无法获取具体信息）
        cerr << "捕获未知异常（无法获取详细信息）" << endl;
    }

    return 0;
}

try {
    // 可能抛出异常的代码
} catch (const SomeException& e) {
    // 预处理逻辑（如记录日志）
    throw;  // 重新抛出原始异常（保持类型不变）
}

#include <iostream>
#include <stdexcept>
using namespace std;

void process_data(int value) {
    if (value < 0) {
        throw invalid_argument("值不能为负数");
    }
    // 处理数据...
}

int main() {
    try {
        process_data(-5);//发生异常
    } catch (const exception& e) {//处理异常
        cerr << "底层捕获异常: " << e.what() << endl;
        
        // 添加额外处理逻辑（如记录日志）
        // throw;  // 重新抛出原始异常（类型保持为 invalid_argument）
        
        // 或者抛出新异常（类型改变）
        throw runtime_error("数据预处理失败: " + string(e.what()));//异常重新抛出
    }
    return 0;
}