C++ 异常处理机制：捕获、自定义与实战

流程很简单：try 块执行代码 → 若出错 throw 抛出 → 跳转到最近的匹配 catch 块 → 执行处理逻辑 → 继续后续执行。

三、基本语法与执行流程

1. 基本语法格式

try {
    // 可能抛出异常的代码块
    可能出错的操作;
    if (错误条件) {
        throw 异常值; // 抛出任意类型：int、string、自定义类等
    }
} catch (异常类型 1 异常变量) {
    // 处理异常类型 1 的逻辑
} catch (异常类型 2 异常变量) {
    // 处理异常类型 2 的逻辑
} catch (...) {
    // 捕获所有未匹配的异常（兜底处理）
}

注意几点：try 块必须紧跟一个或多个 catch 块，不能单独存在；throw 表达式抛出后立即终止当前函数执行；catch 块按顺序匹配，catch (...) 是万能捕获，必须放在最后。

2. 执行流程详解

来看个除数为 0 的例子：

#include <iostream>
using namespace std;

int divide(int a, int b) {
    if (b == 0) {
        throw string("错误：除数不能为 0！");
    }
    return a / b;
}

int main() {
    int x = 10, y = 0;
    try {
        cout << "尝试执行除法运算..." << endl;
        int result = divide(x, y);
        cout << x << " / " << y << " = " << result << endl;
    } catch (const string& err_msg) {
        cout << "捕获到异常：" << err_msg << endl;
    } catch (...) {
        cout << "捕获到未知异常！" << endl;
    }
    cout << "程序继续执行..." << endl;
    return 0;
}

运行结果会显示捕获到了异常，但程序没有崩溃，而是继续执行了最后的输出。这说明异常被成功拦截并处理了。

3. 匹配规则

catch 块按声明顺序匹配异常类型。精确匹配优先，派生类异常可被基类类型的 catch 捕获。这里有个坑：如果将基类异常的 catch 块放在派生类之前，派生类异常会被基类捕获，导致后面的 catch 永远无法执行。

// 错误示例：基类 catch 在前
try {
    throw DerivedException();
} catch (BaseException& e) { // 先匹配基类
    cout << "基类异常" << endl;
} catch (DerivedException& e) { // 永远无法执行
    cout << "派生类异常" << endl;
}

所以记住：派生类在前，基类在后。

4. 标准异常库

C++ 标准库提供了一系列预定义异常类，均继承自 std::exception，定义在 <exception> 头文件中。常用的有：

使用 at() 方法访问 vector 元素越界时会抛出 out_of_range，而 new 失败会抛出 bad_alloc。这些异常类的 what() 方法返回简要描述，方便日志记录。

四、自定义异常类

标准异常虽能满足常见场景，但实际开发中常需要自定义异常（如'用户不存在'、'权限不足'）。自定义异常类需遵循以下原则：继承自标准异常类（推荐 std::exception），重写 what() 方法，提供必要的构造函数，类名清晰体现异常类型。

1. 实现示例

#include <iostream>
#include <exception>
#include <string>
using namespace std;

// 基础业务异常类
class BusinessException : public exception {
private:
    string err_msg;
public:
    BusinessException(const string& msg) : err_msg(msg) {}
    const char* what() const noexcept override {
        return err_msg.c_str();
    }
};

// 派生异常类：用户不存在
class UserNotFoundException : public BusinessException {
public:
    UserNotFoundException(int user_id) 
        : BusinessException("用户不存在：ID=" + to_string(user_id)) {}
};

// 模拟业务函数
void query_user(int user_id) {
    if (user_id < 1000 || user_id > 9999) {
        throw UserNotFoundException(user_id);
    }
    cout << "查询成功：用户 ID=" << user_id << endl;
}

int main() {
    try {
        query_user(123);
    } catch (const UserNotFoundException& e) {
        cout << "业务异常：" << e.what() << endl;
    } catch (const exception& e) {
        cout << "系统异常：" << e.what() << endl;
    }
    return 0;
}

自定义异常的优势在于语义清晰、层次分明、信息丰富且兼容标准。注意 what() 方法必须重写为 const noexcept，符合基类接口规范。

五、高级特性

1. noexcept 关键字

C++11 前可用 throw(类型列表) 声明异常规格，但已废弃。推荐使用 noexcept 声明函数是否可能抛出异常。

void func() noexcept { /* 不抛异常 */ }
void func2() noexcept(false) { /* 可能抛异常 */ }

noexcept 能让编译器省略异常处理代码以提升性能，也能影响标准库行为（如 vector 的移动语义）。但要注意，若 noexcept 函数实际抛出了异常，程序会直接终止，无法捕获。

2. 异常传播与重新抛出

异常抛出后，若无匹配 catch 块，会向上传播直到找到匹配项或到达 main 函数。有时需要在 catch 块中处理部分逻辑后，将异常重新抛出给上层处理，使用 throw;（不带参数）实现。

void handle_request(int data) {
    try {
        process_data(data);
    } catch (const string& e) {
        cout << "日志记录：发生异常 - " << e << endl;
        throw; // 重新抛出原始异常
    }
}

3. 异常安全

异常安全指程序抛出异常时，确保不发生内存泄漏、数据状态一致、资源正确释放。解决方案包括使用智能指针、RAII 模式（资源获取即初始化）以及利用标准库容器。

#include <memory>
void safe_func() {
    unique_ptr<int> p(new int(10));
    throw string("测试异常安全");
    // 无需手动 delete，智能指针析构时自动释放
}

六、常见错误与最佳实践

1. 常见错误

• 过度使用异常：不要将异常用于正常控制流（如查找元素未找到），这会导致效率降低。
• 捕获后忽略：使用 catch (...) 却不处理，相当于吞掉了异常，排查困难。
• 抛出非异常对象：尽量抛出继承自 std::exception 的对象，保持统一。
• 对象切片：按值捕获异常（catch (BaseException e)）会导致派生类特有信息丢失，应按引用捕获。

2. 最佳实践

• 明确场景：仅在异常情况（内存失败、IO 错误）使用异常，正常逻辑用返回值。
• 按引用捕获：使用 catch (const Exception& e) 避免拷贝开销和切片。
• 合理排序：派生类 catch 在前，基类在后，catch (...) 兜底。
• 保证安全：使用智能指针和 RAII 管理资源。
• 记录日志：捕获后记录详细异常信息便于排查。
• 避免析构抛异常：析构函数抛出异常可能导致程序终止。

七、实战案例：文件读写

实现一个文件读写工具类，支持读取和写入，要求处理常见异常、使用自定义异常、保证异常安全。

1. 思路

1. 自定义文件相关异常类（继承自 std::exception）。
2. 基于 RAII 模式实现文件工具类 FileHandler。
3. 在主函数中分层捕获异常，提供友好提示。

2. 代码实现

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <exception>
using namespace std;

// 自定义文件异常基类
class FileException : public exception {
protected:
    string err_msg;
public:
    FileException(const string& filename, const string& reason) {
        err_msg = "文件操作异常：文件\"" + filename + "\", 原因：" + reason;
    }
    const char* what() const noexcept override {
        return err_msg.c_str();
    }
};

// 派生异常：打开失败
class FileOpenException : public FileException {
public:
    FileOpenException(const string& filename, const string& reason)
        : FileException(filename, "打开失败 - " + reason) {}
};

// 文件工具类（RAII 模式）
class FileHandler {
private:
    string filename;
    fstream file_stream;
public:
    FileHandler(const string& filename, ios_base::openmode mode) : filename(filename) {
        file_stream.open(filename, mode);
        if (!file_stream.is_open()) {
            throw FileOpenException(filename, "无法打开文件");
        }
        cout << "日志：文件\"" << filename << "\"打开成功" << endl;
    }

    ~FileHandler() {
        if (file_stream.is_open()) {
            file_stream.close();
            cout << "日志：文件\"" << filename << "\"关闭成功" << endl;
        }
    }

    vector<string> read_file() {
        vector<string> content;
        string line;
        if (!file_stream.good()) {
            throw FileReadException(filename, "文件流状态异常");
        }
        while (getline(file_stream, line)) {
            content.push_back(line);
        }
        if (file_stream.bad()) {
            throw FileReadException(filename, "读取过程中发生 IO 错误");
        }
        return content;
    }

    void write_file(const vector<string>& content) {
        if (!file_stream.good()) {
            throw FileWriteException(filename, "文件流状态异常");
        }
        for (const string& line : content) {
            file_stream << line << endl;
            if (file_stream.fail()) {
                throw FileWriteException(filename, "写入数据失败");
            }
        }
        file_stream.flush();
    }
};

int main() {
    string read_filename = "input.txt";
    string write_filename = "output.txt";
    try {
        FileHandler reader(read_filename, ios::in);
        vector<string> content = reader.read_file();
        
        vector<string> new_content = {"=== 新内容 ===", "这是第一行"};
        FileHandler writer(write_filename, ios::out | ios::trunc);
        writer.write_file(new_content);
    } catch (const FileOpenException& e) {
        cout << "错误提示：" << e.what() << endl;
    } catch (const exception& e) {
        cout << "系统错误：" << e.what() << endl;
    }
    return 0;
}

该工具类通过自定义异常提供了详细错误信息，基于 RAII 保证了资源正确释放，即使发生异常也不会泄漏，符合最佳实践。

八、总结

C++ 异常处理通过 try-catch-throw 实现错误检测与处理的分离，提升代码健壮性。标准异常库提供了常用类，自定义异常应继承自 std::exception。匹配时派生类在前，基类在后。异常安全是关键，需通过智能指针和 RAII 管理资源。实践中要明确使用场景，按引用捕获，记录日志，并避免在析构函数中抛异常。