blocks|key|1104911|text|堆栈展开主要是一个C%2B%2B概念，处理当其作用域退出(正常或通过异常)时，如何销毁堆栈分配的对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1104912|假设你有这段代码：|1104913|void+hw()+{
++++string+hello("Hello,+");
++++string+world("world!\n");
++++cout+<<+hello+<<+world;
}+//+at+this+point,+"world"+is+destroyed,+followed+by+"hello"|code-block|syntax|javascript|1104914|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Stack unwinding is a mostly C++ concept, dealing with how stack-allocated objects are destroyed when its scope is exited (either normally, or through an exception).

Say you have this fragment of code:

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

blocks|key|1104978|text|在一般意义上，堆栈“展开”几乎等同于函数调用的结束和随后的堆栈弹出。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1104979|但是，特别是在C%2B%2B的情况下，堆栈展开必须与C%2B%2B如何调用自任何代码块启动以来分配的对象的析构函数有关。在块中创建的对象将以与其分配顺序相反的顺序释放。|1104980|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In a general sense, a stack "unwind" is pretty much synonymous with the end of a function call and the subsequent popping of the stack.

However, specifically in the case of C++, stack unwinding has to do with how C++ calls the destructors for the objects allocated since the started of any code block. Objects that were created within the block are deallocated in reverse order of their allocation.

blocks|key|1105062|text|当引发异常并将控制从try块传递给处理程序时，C%2B%2B运行时将为自try块开始以来构造的所有自动对象调用析构函数。这个过程被称为堆栈展开。自动对象以与其构造相反的顺序被销毁。(自动对象是已声明为auto或register的本地对象，或未声明为static或extern的本地对象。每当程序退出声明x的块时，自动对象x就会被删除。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1105063|如果在由子对象或数组元素组成的对象的构造过程中抛出异常，则仅对在抛出异常之前成功构造的那些子对象或数组元素调用析构函数。只有在对象成功构造的情况下，才会调用局部静态对象的析构函数。|1105064|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

When an exception is thrown and control passes from a try block to a handler, the C++ run time calls destructors for all automatic objects constructed since the beginning of the try block. This process is called stack unwinding. The automatic objects are destroyed in reverse order of their construction. (Automatic objects are local objects that have been declared auto or register, or not declared static or extern. An automatic object x is deleted whenever the program exits the block in which x is declared.)

If an exception is thrown during construction of an object consisting of subobjects or array elements, destructors are only called for those subobjects or array elements successfully constructed before the exception was thrown. A destructor for a local static object will only be called if the object was successfully constructed.

blocks|key|1105126|text|每个人都在谈论C%2B%2B中的异常处理。但是，我认为堆栈展开还有另一个含义，那就是调试。每当调试器应该转到当前帧之前的帧时，它都必须进行堆栈展开。然而，这是一种虚拟解压，因为当它返回到当前帧时，它需要倒带。例如，gdb中的up/down/bt命令。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1105127|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Everyone has talked about the exception handling in C++. But,I think there is another connotation for stack unwinding and that is related to debugging. A debugger has to do stack unwinding whenever it is supposed to go to a frame previous to the current frame. However, this is sort of virtual unwinding as it needs to rewind when it comes back to current frame. The example for this could be up/down/bt commands in gdb.

blocks|key|1105190|text|C%2B%2B运行时销毁在抛出和捕捉之间创建的所有自动变量。在下面这个简单的示例中，f1()抛出和main()捕获，在类型B和A之间的对象是按该顺序在堆栈上创建的。当f1()抛出时，B和A的析构函数被调用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1105191|#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;
}|code-block|syntax|javascript|1105192|此程序的输出将为|1105193|B's+dtor
A's+dtor|1105194|这是因为当f1()抛出时，程序的调用堆栈看起来像|1105195|f1()
f()
main()|1105196|因此，当弹出f1()时，自动变量b被销毁，然后当f()被弹出时，自动变量a被销毁。|1105197|希望这对你有所帮助，祝你编码愉快！|1105198|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

C++ runtime destructs all automatic variables created between between throw &amp; catch. In this simple example below f1() throws and main() catches, in between objects of type B and A are created on the stack in that order. When f1() throws, B and A's destructors are called.

<pre><code>#include &lt;iostream&gt;
using namespace std;

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

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

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

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

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

 return 0;
}
</code></pre>

The output of this program will be

<pre><code>B's dtor
A's dtor
</code></pre>

This is because the program's callstack when f1() throws looks like

<pre><code>f1()
f()
main()
</code></pre>

So, when f1() is popped, automatic variable b gets destroyed, and then when f() is popped automatic variable a gets destroyed. 

Hope this helps, happy coding!

blocks|key|1105240|text|堆栈展开是在运行时从函数调用堆栈中移除函数条目的过程。它通常与异常处理相关。在C%2B%2B中，当发生异常时，会在函数调用堆栈中线性搜索异常处理程序，将包含异常处理程序的函数之前的所有条目从函数调用堆栈中删除。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1105241|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Stack unwinding is the process of removing function entries from the function call stack at runtime. It generally related to exception handling. In C++ when an exception occurs , the function call stack is linearly searched for the exception handler all the entries before the function with exception handlers are removed from the function call stack .

What is stack unwinding? Searched through but couldn't find enlightening answer!

What is stack unwinding?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

什么是堆栈展开？搜索了一下，但找不到有启发性的答案！

问什么是堆栈展开？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是堆栈展开？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是堆栈展开？
EN