“深入浅出”系列之C++：栈回溯（Stack Unwinding）

在 C++ 中，栈回溯（Stack Unwinding） 是异常处理机制中的一个关键过程。它发生在异常抛出后，负责逆向销毁作用域内已创建的对象，并确保资源得到释放，防止资源泄漏。本文将详细介绍 C++ 栈回溯的原理、工作机制和最佳实践。

一、什么是栈回溯（Stack Unwinding）？

栈回溯 是指当异常发生时，C++ 运行时系统从异常抛出的点开始，沿着调用栈逆向遍历，逐个销毁已经构造完成的对象，直到找到匹配的 catch 块或终止程序。

举例说明

#include <iostream>
#include <stdexcept>

struct Resource {
    Resource() { std::cout << "Resource acquired\n"; }
    ~Resource() { std::cout << "Resource released\n"; }
};

void riskyFunction() {
    Resource res;
    throwstd::runtime_error("Error occurred!");
}

int main() {
    try {
        riskyFunction();
    } catch (conststd::exception& e) {
        std::cerr << "Caught exception: " << e.what() << '\n';
    }
    return 0;
}

输出：

Resource acquired
Resource released
Caught exception: Error occurred!

解释：

1. riskyFunction 中创建了 Resource 对象。

2. 异常被抛出后，C++ 运行时开始栈回溯。

3. 在异常传播前，Resource 的析构函数被调用，释放资源。

4. 异常最终被 catch 捕获。

二、C++ 栈回溯的工作原理

栈回溯的基本流程：

1. 异常抛出 (throw)：在异常被抛出的位置，C++ 运行时开始搜索异常处理器。

2. 逆向销毁对象：销毁当前作用域中的所有已构造对象（调用析构函数）。

3. 查找异常处理器：沿着调用栈向上搜索 catch 块。

4. 捕获异常：如果找到匹配的 catch 块，则控制权转移到该块内。

5. 未捕获异常：如果没有匹配的 catch，则调用 std::terminate() 终止程序。

三、栈回溯的常见问题

1. 对象部分构造与异常

如果异常发生在构造函数内部且对象尚未完全构造完成，C++ 保证只会销毁已完全构造的成员对象。

#include <iostream>

struct A {
    A() { std::cout << "A constructed\n"; }
    ~A() { std::cout << "A destroyed\n"; }
};

struct B {
    B() { 
        std::cout << "B constructed\n"; 
        throwstd::runtime_error("Error in B");
    }
    ~B() { std::cout << "B destroyed\n"; }
};

struct C {
    A a;
    B b;
    C() : a(), b() {}
};

int main() {
    try {
        C c;
    } catch (conststd::exception& e) {
        std::cerr << "Caught exception: " << e.what() << '\n';
    }
    return 0;
}

输出：

A constructed
B constructed
A destroyed
Caught exception: Error in B

解释：

• A 被成功构造，因此其析构函数被调用。

• B 在构造时抛出异常，因此 C 的构造函数未完成，B 的析构函数未被调用。

2. 异常安全与资源泄漏

如果没有正确实现异常安全，异常发生时可能导致资源泄漏。

错误示例：

#include <iostream>

void badFunction() {
    int* ptr = new int[100];  // 动态分配内存
    throw std::runtime_error("Error!");
    delete[] ptr;  // 这行代码永远不会被执行
}

解决方案：使用智能指针：

#include <iostream>
#include <memory>

void goodFunction() {
    auto ptr = std::make_unique<int[]>(100);  // 使用智能指针管理资源
    throw std::runtime_error("Error!");  
    // 资源会在异常发生时自动释放
}

四、noexcept 与栈回溯的关系

1. noexcept 关键字

• noexcept 告诉编译器一个函数不会抛出异常。

• 如果在 noexcept 修饰的函数内抛出异常，将直接调用 std::terminate() 终止程序。

void test() noexcept {
    throw std::runtime_error("Error!");  // 程序会直接终止
}

int main() {
    test();  // 调用 std::terminate()
    return 0;
}

2. 使用场景

• 在性能敏感代码中禁用异常（如内核开发或嵌入式系统）。

• 在移动构造函数和析构函数中使用 noexcept 以优化性能。

五、最佳实践

使用 RAII 保证异常安全

• 资源在对象生命周期内被自动管理。

• 使用智能指针（如 std::unique_ptr 和 std::shared_ptr）。

尽量使用标准库容器

• 避免手动管理内存，使用 std::vector、std::string 等标准容器。

慎用 noexcept

• 仅在有明确的性能需求或需要抑制异常传播时使用 noexcept。

捕获异常类型

• 使用基类 std::exception 捕获异常，以确保能捕获到标准异常类型。

try {
    // 可能抛出异常的代码
} catch (const std::exception& e) {
    std::cerr << "Error: " << e.what() << '\n';
}

六、总结

C++ 栈回溯（Stack Unwinding）是异常处理的核心机制，它确保异常发生时正确释放资源，从而防止资源泄漏。理解栈回溯的原理有助于编写更加健壮且异常安全的 C++ 代码。
通过 RAII、智能指针和标准库容器等工具，开发者可以更好地管理资源，减少异常带来的风险。