所有这些都与c++有关:

定义: 当您静态地创建对象(在堆栈上而不是在堆内存中分配对象)并执行函数调用时，它们是“堆叠起来的”。

当一个作用域(由{和}分隔的任何内容)退出(通过使用return XXX;，到达作用域的末尾或抛出异常)时，该作用域内的所有内容都被销毁(对所有内容调用析构函数)。这个销毁局部对象并调用析构函数的过程称为堆栈展开。

您有以下与堆栈展开相关的问题:

avoiding memory leaks (anything dynamically allocated that is not managed by a local object and cleaned up in the destructor will be leaked) - see RAII referred to by Nikolai, and the documentation for boost::scoped_ptr or this example of using boost::mutex::scoped_lock. program consistency: the C++ specifications state that you should never throw an exception before any existing exception has been handled. This means that the stack unwinding process should never throw an exception (either use only code guaranteed not to throw in destructors, or surround everything in destructors with try { and } catch(...) {}).

如果任何析构函数在堆栈展开过程中抛出异常，那么就会出现未定义的行为，这可能导致程序意外终止(最常见的行为)或整个宇宙结束(理论上是可能的，但在实践中尚未观察到)。

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

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++中管理内存、数据库连接、打开的文件描述符等资源。

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

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

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

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

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

每个人都谈论过c++中的异常处理。但是，我认为堆栈展开还有另一个内涵，它与调试有关。调试器必须在应该转到当前帧之前的帧时进行堆栈展开。然而，这是一种虚拟unwind，因为当它回到当前帧时需要倒带。例如gdb中的up/down/bt命令。

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

假设你有这样一段代码:

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