C++ Stack Unwinding：异常传播与栈展开的机制

好的，各位观众，欢迎来到“C++ Stack Unwinding：异常传播与栈展开的机制”特别节目！我是你们今天的“异常处理大师”——老码农。今天咱们不搞虚的，直接上干货，扒一扒C++异常处理那点事儿，重点聊聊这“栈展开”到底是咋回事。

开场白：异常，程序员的噩梦，也是代码的守护神

相信各位都经历过这样的场景：辛辛苦苦写了几百行代码，一运行，Duang！崩溃了！屏幕上弹出个“未处理的异常”……当时的心情，估计比吃了一斤苍蝇还难受。

但凡事都有两面性。异常，虽然看起来像bug的放大版，但其实也是我们代码的守护神。它能让我们在程序出错的时候，不至于直接嗝屁，而是有机会优雅地处理错误，挽救局面。

第一幕：C++异常处理的基本姿势

C++的异常处理机制，简单来说就是三个关键字：try、catch和throw。

try：把可能出错的代码放到try块里，相当于给这段代码上了个“保险”。
catch：如果try块里的代码真的出错了，就用catch块来“抓住”这个错误，并进行处理。
throw：当程序发现自己不行了，解决不了问题了，就用throw抛出一个异常，把烂摊子交给别人处理。

来个简单的例子：

#include <iostream>
#include <stdexcept> // 引入标准异常类

using namespace std;

int divide(int a, int b) {
    if (b == 0) {
        throw runtime_error("除数不能为零！"); // 抛出一个标准异常
    }
    return a / b;
}

int main() {
    int x, y;
    cout << "请输入两个整数：";
    cin >> x >> y;

    try {
        int result = divide(x, y);
        cout << "结果是：" << result << endl;
    } catch (const runtime_error& error) {
        cerr << "发生异常：" << error.what() << endl; // 打印错误信息
    } catch (...) {
        cerr << "未知异常发生了！" << endl; // 捕获所有其他异常
    }

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

在这个例子中，divide函数负责做除法。如果除数为0，它就throw一个runtime_error异常。main函数用try块包裹了调用divide的代码。如果divide抛出了异常，catch块就会捕获它，并打印错误信息。

第二幕：异常的传播之路

重点来了！如果try块里的函数调用了其他函数，而其他函数又调用了更深层的函数，异常会怎么传播呢？

答案是：异常会沿着调用链往上传播，直到找到能够处理它的catch块。如果一直传到main函数都没有找到合适的catch块，程序就会崩溃，调用std::terminate()函数，这可不是我们想要的！

再来个例子：

#include <iostream>
#include <stdexcept>

using namespace std;

void functionC() {
    cout << "functionC: 开始执行" << endl;
    throw runtime_error("functionC 抛出的异常");
    cout << "functionC: 执行结束 (这行不会被执行)" << endl;
}

void functionB() {
    cout << "functionB: 开始执行" << endl;
    functionC();
    cout << "functionB: 执行结束 (这行也不会被执行)" << endl;
}

void functionA() {
    cout << "functionA: 开始执行" << endl;
    try {
        functionB();
    } catch (const runtime_error& error) {
        cerr << "functionA: 捕获到异常: " << error.what() << endl;
    }
    cout << "functionA: 执行结束" << endl;
}

int main() {
    cout << "main: 程序开始" << endl;
    functionA();
    cout << "main: 程序结束" << endl;
    return 0;
}

在这个例子中，functionC抛出了异常。functionB没有try-catch块，所以异常会继续往上传播到functionA。functionA的try-catch块捕获了异常，并进行了处理。

第三幕：栈展开的英雄本色

现在，我们终于要讲到今天的重头戏——栈展开（Stack Unwinding）了！

当异常被抛出，但当前函数没有catch块来处理它时，C++会启动栈展开机制。栈展开的过程，就像多米诺骨牌一样，一个接一个地倒下：

查找catch块： 从抛出异常的函数开始，沿着函数调用链向上查找，看看有没有合适的catch块可以处理这个异常。
清理局部变量： 在向上查找的过程中，每经过一个函数，都要销毁这个函数中的局部变量。这可不是简单的内存释放，而是要调用这些局部变量的析构函数！
继续传播： 如果找到合适的catch块，就执行catch块中的代码。如果没有找到，就继续向上查找，直到找到或者到达main函数。

用图表来表示：

阶段	描述
1. 异常抛出	函数内部发现错误，使用`throw`抛出异常。
2. 查找处理	沿调用栈向上查找匹配的`catch`块。
3. 栈展开	销毁沿途函数的局部对象，调用析构函数。
4. 异常处理	找到匹配的`catch`块，执行异常处理代码。
5. 继续执行	如果异常被处理，程序可以从`catch`块后继续执行。

栈展开的重要性：RAII的完美体现

栈展开，是C++中RAII（Resource Acquisition Is Initialization，资源获取即初始化）思想的重要体现。RAII的核心思想是：把资源（比如内存、文件句柄、锁）的获取和释放，与对象的生命周期绑定在一起。当对象被创建时，获取资源；当对象被销毁时，释放资源。

在栈展开的过程中，C++会调用局部变量的析构函数。而RAII对象，通常会在析构函数中释放资源。这样，即使程序抛出了异常，也能保证资源被正确地释放，避免内存泄漏、文件句柄泄露等问题。

来个例子：

#include <iostream>
#include <fstream>
#include <stdexcept>

using namespace std;

class FileWrapper {
private:
    ofstream file;
    string filename;

public:
    FileWrapper(const string& filename) : filename(filename) {
        file.open(filename);
        if (!file.is_open()) {
            throw runtime_error("无法打开文件: " + filename);
        }
        cout << "FileWrapper: 打开文件 " << filename << endl;
    }

    ~FileWrapper() {
        if (file.is_open()) {
            file.close();
            cout << "FileWrapper: 关闭文件 " << filename << endl;
        }
    }

    void write(const string& data) {
        file << data << endl;
    }
};

void writeToFile(const string& filename, const string& data) {
    FileWrapper file(filename); // RAII 对象
    file.write(data);
    throw runtime_error("模拟写入文件时发生的异常"); // 模拟异常
}

int main() {
    try {
        writeToFile("test.txt", "Hello, World!");
    } catch (const runtime_error& error) {
        cerr << "main: 捕获到异常: " << error.what() << endl;
    }

    cout << "main: 程序结束" << endl;
    return 0;
}

在这个例子中，FileWrapper类封装了文件操作。它的构造函数打开文件，析构函数关闭文件。在writeToFile函数中，创建了一个FileWrapper对象。即使writeToFile函数抛出了异常，FileWrapper对象的析构函数也会被调用，保证文件被正确地关闭。

第四幕：异常处理的注意事项

不要吞噬异常： 除非你真的知道该怎么处理这个异常，否则不要简单地catch住它，然后什么都不做。这样会隐藏错误，让问题变得更难排查。最好重新throw或者抛出一个新的更有意义的异常。
catch(...)要慎用： catch(...)可以捕获所有类型的异常，但同时也意味着你不知道捕获的是什么异常。除非你真的需要捕获所有异常，否则应该尽量使用更具体的catch块。
异常规范（Exception Specification）： C++11之前，可以用throw()来声明函数不会抛出异常。但这个特性已经被废弃了。现在，可以使用noexcept来声明函数不会抛出异常。如果noexcept函数抛出了异常，程序会直接调用std::terminate()函数，直接退出。这样做，可以避免栈展开的开销，提高程序的性能。
避免在析构函数中抛出异常： 析构函数抛出异常，是很危险的。如果在栈展开的过程中，一个对象的析构函数抛出了异常，而这个异常没有被捕获，程序会直接调用std::terminate()函数，直接退出。
使用智能指针： 智能指针（比如unique_ptr、shared_ptr）是RAII的完美体现。它们可以自动管理内存，避免内存泄漏。

第五幕：性能考量

异常处理虽然强大，但也是有代价的。

运行时开销： 即使没有异常发生，try-catch块也会带来一定的运行时开销。编译器需要生成额外的代码，来支持异常处理。
栈展开开销： 栈展开的过程，需要销毁沿途函数的局部变量，调用析构函数。这个过程，会带来额外的性能开销。

因此，在设计程序的时候，要权衡异常处理的必要性和性能开销。对于性能要求很高的代码，可以考虑使用其他的错误处理方式，比如返回错误码。

第六幕：自定义异常类

C++标准库提供了一些标准的异常类，比如runtime_error、logic_error等。但有时候，我们需要自定义异常类，来表示特定的错误情况。

自定义异常类，通常需要继承自std::exception或者其子类。需要重写what()方法，来返回错误信息。

来个例子：

#include <iostream>
#include <exception>
#include <string>

using namespace std;

class MyException : public exception {
private:
    string message;

public:
    MyException(const string& message) : message(message) {}

    const char* what() const noexcept override {
        return message.c_str();
    }
};

int main() {
    try {
        throw MyException("这是一个自定义异常");
    } catch (const MyException& error) {
        cerr << "捕获到自定义异常: " << error.what() << endl;
    }

    return 0;
}

总结：异常处理，代码的最后一道防线

C++的异常处理机制，为我们提供了一种强大的错误处理方式。通过try-catch块，我们可以捕获和处理异常，保证程序的健壮性。栈展开机制，则保证了在异常发生时，资源能够被正确地释放。

但是，异常处理也不是万能的。我们需要谨慎使用，避免滥用，权衡性能开销。

记住，异常处理，是代码的最后一道防线。只有在其他错误处理方式都失效的情况下，才应该使用异常处理。

好了，今天的“C++ Stack Unwinding：异常传播与栈展开的机制”特别节目就到这里。希望大家有所收获！咱们下期再见！

发表回复 取消回复

发表回复取消回复