C++朝花夕拾-异常机制

字数统计: 2.2k字   |   阅读时长≈ 9分

🚨 C++ 异常机制 —— 从零到精通

💡 一句话总结：
“异常 = 程序运行时发生的‘意外情况’，C++ 用 throw, try, catch 三剑客来处理它，让程序不崩溃、能恢复、有尊严地报错。”

🎯 一、为什么要学异常？—— 先看“没有异常”的痛苦

👶 传统错误处理方式：返回错误码（return -1, NULL, false…）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int divide(int a, int b) {
    if (b == 0) {
        return -1; // 用 -1 表示“除零错误”
    }
    return a / b;
}

int main() {
    int result = divide(10, 0);
    if (result == -1) {
        cout << "错误：除数不能为0！" << endl;
    } else {
        cout << "结果是：" << result << endl;
    }
}

❗ 问题来了：

  • 如果忘记检查返回值？→ 程序逻辑错乱！
  • 如果函数要返回“正常值”和“错误码”？→ 设计混乱！
  • 如果错误发生在“深层调用”中？→ 一层层往上传，代码臃肿！

🌟 二、异常机制登场 —— throw, try, catch

C++ 异常机制三大关键字：

关键字 作用
throw 抛出一个异常（相当于“报警”）
try 包裹可能出错的代码（“监控区”）
catch 捕获并处理异常（“接警处理”）

🎬 生活化比喻：餐厅点餐

  • 你点了一份“牛排” → try { 点餐(); }
  • 厨房发现“牛肉卖完了” → throw "没牛肉了！";
  • 服务员接到通知 → catch (string msg) { 告诉顾客 + 推荐别的菜 }
  • 顾客不会因为“没牛肉”掀桌子（程序不崩溃），而是优雅换菜 😊

🧩 三、基本语法 + 示例

✅ 1. 抛出异常：throw 表达式;

1
2
3
4
5
6
7
8
9
void checkAge(int age) {
    if (age < 0) {
        throw "年龄不能为负数！"; // 抛出字符串异常
    }
    if (age > 150) {
        throw 999; // 抛出整数异常（不推荐，但合法）
    }
    cout << "年龄合法：" << age << endl;
}

💡 throw 可以抛出 任何类型：int, string, char*, 自定义类对象等
✅ 推荐抛出 异常类对象（后文讲）

✅ 2. 捕获异常：try { ... } catch (...) { ... }

1
2
3
4
5
6
7
8
9
10
11
12
int main() {
    try {
        checkAge(-5); // 可能抛异常
    } catch (const char* msg) { // 捕获 char* 类型异常
        cout << "捕获到异常：" << msg << endl;
    } catch (int code) { // 捕获 int 类型异常
        cout << "错误代码：" << code << endl;
    }

    cout << "程序继续运行..." << endl;
    return 0;
}

🖨️ 输出：

1
2
捕获到异常：年龄不能为负数！
程序继续运行...

🧱 四、异常的传播（栈展开 —— Stack Unwinding）

❓ 问题：如果异常发生在“函数调用深处”，怎么办？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void func3() {
    throw "func3 出错了！";
}

void func2() {
    func3(); // func3 抛异常
    cout << "这行不会执行！" << endl;
}

void func1() {
    func2();
}

int main() {
    try {
        func1(); // 异常从 func3 一路“冒泡”到 main
    } catch (const char* msg) {
        cout << "main 捕获：" << msg << endl;
    }
}

🔄 栈展开过程：

  1. func3() 抛异常
  2. func3() 立刻退出 → 析构局部对象
  3. func2() 退出 → 析构局部对象
  4. func1() 退出 → 析构局部对象
  5. main() 的 catch 捕获异常 → 程序继续

✅ 关键点：异常会沿着调用栈“向上传播”，直到被捕获，中间函数全部退出（局部对象被析构）！

🧰 五、标准异常类（推荐使用！）

C++ 标准库提供了一套异常类（在 <stdexcept> 中），建议优先使用：

异常类 用途
std::runtime_error 运行时错误（如文件打不开）
std::logic_error 逻辑错误（如传参错误）
std::invalid_argument 无效参数
std::out_of_range 越界访问（如 vector）

✅ 示例：使用标准异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdexcept>
#include <iostream>
using namespace std;

double divide(double a, double b) {
    if (b == 0.0) {
        throw invalid_argument("除数不能为零！");
    }
    return a / b;
}

int main() {
    try {
        cout << divide(10.0, 0.0) << endl;
    } catch (const invalid_argument& e) {
        cout << "参数错误：" << e.what() << endl;
    } catch (const exception& e) { // 基类，捕获所有标准异常
        cout << "标准异常：" << e.what() << endl;
    }

    return 0;
}

📌 .what() 是 std::exception 的虚函数，返回错误描述字符串。

🛠️ 六、自定义异常类（高级用法）

你可以继承 std::exception 或其子类，创建自己的异常：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class MyException : public std::exception {
private:
    string msg;
public:
    MyException(const string& m) : msg(m) {}
    const char* what() const noexcept override {
        return msg.c_str();
    }
};

void riskyFunction() {
    throw MyException("我的自定义异常！");
}

int main() {
    try {
        riskyFunction();
    } catch (const MyException& e) {
        cout << "捕获自定义异常：" << e.what() << endl;
    }
}

✅ 自定义异常 = 更精确的错误分类 + 更丰富的错误信息！

⚠️ 七、异常规范（C++11 起已废弃，了解即可）

老版本 C++ 支持异常规范：

1
2
void func() throw(int); // 只允许抛 int 异常（已废弃）
void func() throw();    // 不允许抛任何异常（已废弃）

🚫 C++11 起废弃，改用 noexcept：

1
2
3
void safeFunc() noexcept { // 承诺不抛异常
    // 如果这里 throw 了 → std::terminate() 程序终止！
}

🔄 八、重新抛出异常（throw;）

在 catch 块中，你可以“处理一部分，再抛出去”：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void handlePartially() {
    try {
        riskyOperation();
    } catch (...) {
        cout << "记录日志：发生异常！" << endl;
        throw; // 重新抛出当前异常（不改变类型！）
    }
}

int main() {
    try {
        handlePartially();
    } catch (const char* msg) {
        cout << "最终处理：" << msg << endl;
    }
}

✅ 用途：日志记录、资源清理、部分处理后交给上层。

🧹 九、异常安全与 RAII（重要！）

❗ 异常可能导致资源泄漏！

1
2
3
4
5
void badExample() {
    int* p = new int[1000];
    riskyFunction(); // 如果这里抛异常 → p 永远不会 delete！
    delete[] p;
}

✅ 解决方案：RAII + 智能指针

1
2
3
4
5
6
#include <memory>
void goodExample() {
    auto p = std::make_unique<int[]>(1000); // 智能指针
    riskyFunction(); // 即使抛异常，p 也会自动析构！
    // 不用手动 delete
}

🌟 RAII 原则：资源获取即初始化，绑定对象生命周期 → 异常时自动释放！

🚫 十、不要在析构函数中抛异常！

1
2
3
4
5
6
class BadClass {
public:
    ~BadClass() {
        throw "析构函数抛异常！"; // ❌ 危险！
    }
};

💥 如果析构函数抛异常，且当前正在处理另一个异常 → std::terminate() 程序直接终止！

✅ 正确做法：在析构函数中用 try-catch 吞掉异常，或记录日志。

📊 十一、异常的性能开销

  • 无异常时：现代编译器优化得很好，几乎无开销
  • 抛异常时：栈展开、查找 catch 块 → 开销较大（比 if-else 慢很多）
  • ✅ 建议：异常用于“真正异常”的情况（如文件打不开、网络断开），不要用于控制流程！

🧠 十二、异常 vs 错误码 —— 如何选择？

场景 推荐方式
频繁发生的“可预期”错误（如用户输错） ✅ 错误码
罕见、严重、不可恢复的错误（如内存不足、文件损坏） ✅ 异常
库函数、API 设计 ✅ 异常（更安全、不易忽略）
性能敏感代码（游戏循环、高频交易） ✅ 错误码

🎓 十三、完整实战示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept>
using namespace std;

class ConfigFile {
    string filename;
public:
    ConfigFile(const string& fname) : filename(fname) {}

    string load() {
        ifstream file(filename);
        if (!file.is_open()) {
            throw runtime_error("无法打开配置文件: " + filename);
        }

        string content, line;
        while (getline(file, line)) {
            content += line + "\n";
        }
        return content;
    }
};

int main() {
    ConfigFile cfg("config.txt");

    try {
        string data = cfg.load();
        cout << "配置内容：\n" << data << endl;
    } catch (const runtime_error& e) {
        cerr << "加载失败：" << e.what() << endl;
        return 1;
    } catch (...) {
        cerr << "未知错误！" << endl;
        return 2;
    }

    cout << "程序正常结束。" << endl;
    return 0;
}

📌 总结：C++ 异常机制核心要点

概念 说明
throw 抛出异常，中断当前函数
try-catch 捕获并处理异常，防止程序崩溃
栈展开 异常向上传播，中间函数退出，局部对象析构
标准异常 优先使用 std::exception 及其子类
自定义异常 继承 std::exception，重写 what()
noexcept 声明函数不抛异常（C++11）
throw; 重新抛出当前异常
RAII 用对象管理资源，确保异常时自动释放
析构函数 绝对不要抛异常！
性能 异常用于“真异常”，不要滥用

🧩 考考你！

下面代码会输出什么？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
using namespace std;

struct A {
    A() { cout << "A 构造" << endl; }
    ~A() { cout << "A 析构" << endl; }
};

void func() {
    A a;
    throw "出错了！";
    cout << "这行不会执行" << endl;
}

int main() {
    try {
        func();
    } catch (const char* msg) {
        cout << "捕获：" << msg << endl;
    }
    return 0;
}

✅ 答案：

1
2
3
A 构造
A 析构
捕获：出错了！

🌟 解释：即使 throw 中断了 func()，局部对象 a 仍会析构！这就是 栈展开 + RAII 的威力！

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

僕は新世界の神となる!