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

假设你有这样一段代码:

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

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

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++中，当发生异常时，函数调用堆栈会线性地搜索异常处理程序，在带有异常处理程序的函数之前的所有条目都将从函数调用堆栈中删除。

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

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被销毁。

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

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

在图片中:

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

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