第一节 · 匹配想法 · 正则表达式

程序运行时总会遇到各种意外情况。异常处理提供了一种结构化的方式来处理运行时错误。

---

基本异常处理

#include <stdexcept>

double divide(double a, double b)
{
    if (b == 0)
    {
        throw runtime_error("Division by zero!");
    }
    return a / b;
}

int main()
{
    try
    {
        cout << divide(10, 2) << endl;  // 5
        cout << divide(10, 0) << endl;  // 抛出异常
    }
    catch (const runtime_error& e)
    {
        cerr << "Error: " << e.what() << endl;
    }
    
    cout << "Program continues..." << endl;
    return 0;
}

---

异常类层次

exception
├── logic_error
│   ├── invalid_argument
│   ├── domain_error
│   ├── length_error
│   └── out_of_range
├── runtime_error
│   ├── range_error
│   ├── overflow_error
│   ├── underflow_error
│   └── system_error
└── bad_alloc, bad_cast, bad_typeid...

#include <stdexcept>
#include <vector>

int main()
{
    try
    {
        vector<int> v = {1, 2, 3};
        cout << v.at(10) << endl;  // 抛出 out_of_range
    }
    catch (const out_of_range& e)
    {
        cerr << "Out of range: " << e.what() << endl;
    }
    
    try
    {
        int* p = new int[1000000000000];  // 可能失败
    }
    catch (const bad_alloc& e)
    {
        cerr << "Allocation failed: " << e.what() << endl;
    }
    
    return 0;
}

---

多重 catch

void process(int code)
{
    switch (code)
    {
        case 1: throw runtime_error("Runtime error");
        case 2: throw logic_error("Logic error");
        case 3: throw 42;  // 抛出 int
        default: throw "Unknown error";  // 抛出 const char*
    }
}

int main()
{
    for (int i = 1; i <= 4; ++i)
    {
        try
        {
            process(i);
        }
        catch (const runtime_error& e)
        {
            cerr << "Runtime: " << e.what() << endl;
        }
        catch (const logic_error& e)
        {
            cerr << "Logic: " << e.what() << endl;
        }
        catch (int n)
        {
            cerr << "Int exception: " << n << endl;
        }
        catch (...)  // 捕获所有其他异常
        {
            cerr << "Unknown exception" << endl;
        }
    }
    
    return 0;
}

---

自定义异常

class MyException : public exception
{
private:
    string message;
    int errorCode;
    
public:
    MyException(const string& msg, int code)
        : message(msg), errorCode(code) {}
    
    const char* what() const noexcept override
    {
        return message.c_str();
    }
    
    int getCode() const { return errorCode; }
};

void doSomething()
{
    throw MyException("Something went wrong", 42);
}

int main()
{
    try
    {
        doSomething();
    }
    catch (const MyException& e)
    {
        cerr << "Error " << e.getCode() << ": " << e.what() << endl;
    }
    
    return 0;
}

---

noexcept 声明

// 声明函数不会抛出异常
void safeFunction() noexcept
{
    // 不应该抛出异常
}

// 条件 noexcept
template<typename T>
void swap(T& a, T& b) noexcept(is_nothrow_move_constructible_v<T>)
{
    T temp = move(a);
    a = move(b);
    b = move(temp);
}

// 检查是否 noexcept
int main()
{
    cout << noexcept(safeFunction()) << endl;  // 1
    
    return 0;
}

为什么重要？

• 移动构造/赋值应该是 noexcept

• 允许编译器优化

• STL 容器会利用 noexcept 信息

---

异常安全性

// 基本保证：发生异常时，对象仍处于有效状态
// 强保证：发生异常时，程序状态不变（回滚）
// 无抛出保证：绝不抛出异常

class Stack
{
    vector<int> data;
    
public:
    // 强保证的实现
    void push(int value)
    {
        data.push_back(value);  // 如果失败，data 不变
    }
    
    // 危险的实现（基本保证）
    int popBad()
    {
        int top = data.back();
        data.pop_back();
        return top;  // 如果复制抛出异常，元素已经丢失！
    }
    
    // 更安全的设计
    int top() const { return data.back(); }
    void pop() { data.pop_back(); }  // 分离读取和删除
};

---

RAII 与异常

class File
{
    FILE* fp;
public:
    File(const char* name) : fp(fopen(name, "r"))
    {
        if (!fp) throw runtime_error("Cannot open file");
    }
    
    ~File()
    {
        if (fp) fclose(fp);
    }
};

void process()
{
    File f("data.txt");  // 如果构造失败，抛出异常
    // ... 处理文件 ...
    throw runtime_error("Processing error");
    // f 的析构函数仍会被调用！
}

int main()
{
    try
    {
        process();
    }
    catch (...)
    {
        // 文件已被正确关闭
    }
    
    return 0;
}

---

重新抛出异常

void intermediate()
{
    try
    {
        // 可能抛出异常的代码
        throw runtime_error("Original error");
    }
    catch (const exception& e)
    {
        cout << "Logging: " << e.what() << endl;
        throw;  // 重新抛出当前异常
    }
}

void caller()
{
    try
    {
        intermediate();
    }
    catch (const exception& e)
    {
        cout << "Handled: " << e.what() << endl;
    }
}

---

异常与构造函数

class Resource
{
    int* data;
public:
    Resource(int size)
    {
        if (size < 0)
            throw invalid_argument("Size must be non-negative");
        
        data = new int[size];  // 可能抛出 bad_alloc
    }
    
    ~Resource()
    {
        delete[] data;
    }
};

// 如果构造函数抛出异常，析构函数不会被调用
// 已分配的资源需要在 catch 块中处理

---

function-try-block

class MyClass
{
    Resource r1;
    Resource r2;
    
public:
    MyClass()
    try : r1(10), r2(20)  // 初始化列表
    {
        // 构造函数体
    }
    catch (const exception& e)
    {
        cerr << "Construction failed: " << e.what() << endl;
        throw;  // 必须重新抛出或抛出新异常
    }
};

---

习题

• 实现一个带有详细错误信息的自定义异常类。

• 解释强异常安全保证与基本异常安全保证的区别。

• 为什么析构函数不应该抛出异常？