c++运行时销毁在throw和catch之间创建的所有自动变量。在下面这个简单的例子中，f1()抛出和main()捕获，在B和A类型的对象之间按此顺序在堆栈上创建。当f1()抛出时，将调用B和A的析构函数。

#include <iostream>
using namespace std;

class A
{
    public:
       ~A() { cout << "A's dtor" << endl; }
};

class B
{
    public:
       ~B() { cout << "B's dtor" << endl; }
};

void f1()
{
    B b;
    throw (100);
}

void f()
{
    A a;
    f1();
}

int main()
{
    try
    {
        f();
    }
    catch (int num)
    {
        cout << "Caught exception: " << num << endl;
    }

    return 0;
}

这个程序的输出将是

B's dtor
A's dtor

这是因为f1()抛出时程序的调用堆栈看起来像

f1()
f()
main()

因此，当f1()被弹出时，自动变量b被销毁，然后当f()被弹出时，自动变量a被销毁。

希望对大家有所帮助，编码愉快!

堆栈展开通常与异常处理有关。这里有一个例子:

void func( int x )
{
    char* pleak = new char[1024]; // might be lost => memory leak
    std::string s( "hello world" ); // will be properly destructed

    if ( x ) throw std::runtime_error( "boom" );

    delete [] pleak; // will only get here if x == 0. if x!=0, throw exception
}

int main()
{
    try
    {
        func( 10 );
    }
    catch ( const std::exception& e )
    {
        return 1;
    }

    return 0;
}

在这里，如果抛出异常，分配给pleak的内存将丢失，而分配给s的内存将在任何情况下通过std::string析构函数正确释放。当退出作用域时，在堆栈上分配的对象将被“解开”(这里的作用域是函数func的作用域)。这是通过编译器插入对自动(堆栈)变量析构函数的调用来完成的。

现在，这是一个非常强大的概念，导致称为RAII的技术，即资源获取即初始化，它帮助我们在c++中管理内存、数据库连接、打开的文件描述符等资源。

现在这允许我们提供异常安全保证。

堆栈展开主要是c++的概念，处理当堆栈分配的对象的作用域退出时(正常退出或通过异常退出)如何销毁。

假设你有这样一段代码:

void hw() {
    string hello("Hello, ");
    string world("world!\n");
    cout << hello << world;
} // at this point, "world" is destroyed, followed by "hello"

在Java堆栈中，不宽或不伤人不是很重要(使用垃圾收集器)。在许多异常处理论文中，我看到了这个概念(堆栈展开)，特别是那些作者在C或c++中处理异常处理。对于try catch块，我们不应该忘记:在局部块之后释放所有对象的堆栈。

在一般意义上，堆栈“unwind”几乎等同于函数调用的结束和随后的堆栈弹出。

然而，特别是在c++的情况下，堆栈展开必须与c++如何调用自任何代码块开始分配的对象的析构函数有关。在块中创建的对象将按照其分配的相反顺序被释放。

在我看来，本文中给出的下图漂亮地解释了堆栈unwind对下一条指令路径的影响(一旦抛出未捕获的异常，将执行):

在图片中:

上面一个是正常的调用执行(没有抛出异常)。 当抛出异常时，位于底部。

在第二种情况下，当发生异常时，将在函数调用堆栈中线性搜索异常处理程序。搜索结束于带有异常处理程序的函数，即带有try-catch块的main()，但不是在从函数调用堆栈中删除它之前的所有条目之前。