blocks|key|2343151|text|递归调用函数就像任何其他函数一样。因此，内存的分配方式与调用任何常规函数的方式相同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2343152|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|$]]

Calling a function recursively is done just like any other function. So the memory will be allocated the same way as if you are calling any regular function.

blocks|key|1347177|text|它与调用任何其他函数相同。变量(而不是引用传递的变量)被分配到堆栈上。当函数开始返回时(即到达基本情况)，堆栈将按每次嵌套递归调用中推到堆栈的顺序弹出。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1347178|这个youtube视频很好地解释了递归函数的调用堆栈：https://www.youtube.com/watch?v=k0bb7UYy0pY|offset|length|1347179|entityMap|0|LINK|mutability|MUTABLE|url|https://www.youtube.com/watch?v=k0bb7UYy0pY^0|0|R|17|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

It is the same as calling any other function. The variables (not reference-passed ones) get allocated on the stack. When the functions start to return (i.e. base case is reached), the stack gets popped out in the order it was pushed to the stack over each nested recursive call. 

This youtube video explains the call stack for recursive functions really well: <a href="https://www.youtube.com/watch?v=k0bb7UYy0pY" rel="nofollow">https://www.youtube.com/watch?v=k0bb7UYy0pY</a>

blocks|key|2064924|text|当一个函数(如果func1调用)调用另一个函数(称为func2)时，执行func2所需的数据将被推送到堆栈中。对于递归函数(当func2与func1相同时)，这种情况不会改变。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2064925|如果递归函数被递归地调用10，则会出现10堆栈帧，每个帧对应于函数的一次调用。|2064926|entityMap^0|8|5|Q|5|10|5|1R|5|1X|5|0|C|2|J|2|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|I|$]]

When a function (call if <code>func1</code>) calls another function (call it <code>func2</code>), the data necessary for execution of <code>func2</code> is pushed on to the stack. That does not change for recursive functions (when <code>func2</code> is the same as <code>func1</code>).

If a recursive function gets called <code>10</code> times recursively, there will <code>10</code> stack frames, each corresponding to one invocation of the function.

blocks|key|2064933|text|当一个函数被调用时，必要的参数被推到堆栈上。当函数完成其任务时，弹出参数并还原程序计数器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2064934|递归函数也不例外。|2064935|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 a function is called, necessary params are pushed onto stack. When a function finishes its task, the params are poped out and program counter is restored.

There is no exception for recursive functions.

blocks|key|1347235|text|函数参数和局部变量被分配到堆栈上。他们形成了一个所谓的堆栈框架.当函数被递归调用时，为函数的每个递归调用分配堆栈帧。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1347236|例如，如果void+()被递归地调用了三次。|1347237|//+Assume+stack+grows+upwards
stack+frame+#3+<==+the+most+recent+call
stack+frame+#2
stack+frame+#1|code-block|syntax|javascript|1347238|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Call_stack^0|R|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Function parameters and local variables are allocated on the stack. They form a so-called <a href="http://en.wikipedia.org/wiki/Call_stack" rel="nofollow">stack frame</a>. When a function is called recursively, a stack frame is allocated for each of the recursive call of the function.

E.g. if void f() is recursively called three times.

<pre><code>// Assume stack grows upwards
stack frame #3 &lt;== the most recent call
stack frame #2
stack frame #1
</code></pre>

blocks|key|1347282|text|自动变量的内存在堆栈上分配。当您调用另一个函数(递归自或其他函数)时，堆栈帧到目前为止仍然处于它们的状态，我们在堆栈上分配更多的内存(我们这样说)，以存放这个新函数的局部变量。当函数结束时，新的堆栈帧将被丢弃，我们将恢复到以前的(calee)堆栈帧。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1347283|您可以使用您选择的任何调试器来更好地理解事物。如果你不明白什么，请问。|1347284|entityMap|0|LINK|mutability|MUTABLE|url|http://www.tenouk.com/Bufferoverflowc/Bufferoverflow2a.html^0|8|2|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Memory for automatic variables is allocated on <a href="http://www.tenouk.com/Bufferoverflowc/Bufferoverflow2a.html" rel="nofollow">stack</a>. When you call another function (recursively self or some other), stack frames so far remain in their state, and we allocate more memory (let's say it like this) on stack to lodge the local variables of this new function. When the function ends, the new stack frame is discarded and we revert to previous (calee) stack frame.

You can play with any debugger of your choice to understand things even better. If you don't understand something, please ask.

blocks|key|1347291|text|递归使用堆栈内存来执行|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1347292|通过下面的示例|1347293|void+rev(Node*+head){
if(head==NULL)+return;
head=head->next;
rev(head);
cout<<head->data<<endl;}|code-block|syntax|javascript|1347294|让我们来看看Stack段中的递归。|1347295|设NODE1+->+NODE2->NULL，其中NODE1和NODE2是struct对象。|offset|length|style|CODE|1347296|你的职责是：|1347297|Call+to+rev(NODE1)
Check+if+it+is+NULL
Point+to+next+NODE+i.e.+NODE2

Call+to+rev(NODE2)

Check+if+It+is+NULL
Point+to+next+NODE+i.e.+NULL

Call+to+rev(NULL)

Check+if+It+is+NULL
Pointer+will+be+returned+With+head+=+NULL|1347298|希望这能帮到你。|1347299|entityMap^0|0|0|0|0|1|K|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|12|8|@$M|13|N|14|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|17|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

The Recurtion uses Stack memory to get executed 

Go through the below example

<pre><code>void rev(Node* head){
if(head==NULL) return;
head=head-&gt;next;
rev(head);
cout&lt;&lt;head-&gt;data&lt;&lt;endl;}
</code></pre>

Lets have a look in Stack Segment for recursion.

Let <code>NODE1 -&gt; NODE2-&gt;NULL</code> Where NODE1 and NODE2 are struct objects.

What your function doing is:

<pre><code>Call to rev(NODE1)
Check if it is NULL
Point to next NODE i.e. NODE2

Call to rev(NODE2)

Check if It is NULL
Point to next NODE i.e. NULL

Call to rev(NULL)

Check if It is NULL
Pointer will be returned With head = NULL
</code></pre>

Hope this will Help you.

blocks|key|2343286|text|递归函数与任何其他函数没有什么不同--自动局部变量被分配为单个块，方法是将堆栈指针向前推进到足以计算其大小之和(加上对齐所需的任何填充)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2343287|每个递归调用都以这种方式推送一个新堆栈框架，然后当它返回时弹出它。如果递归未能到达基本情况，堆栈将迅速耗尽，从而导致同名堆栈溢出崩溃。|2343288|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|$]]

A recursive function is no different from any other function--automatic local variables are allocated as a single block by advancing the stack pointer far enough to account for the sum of their sizes (plus any padding required for alignment).

Each recursive call pushes a new stack frame in that manner, then pops it when it returns. If the recursion fails to reach a base case, the stack will rapidly be exhausted leading to the eponymous Stack Overflow crash.

blocks|key|2343294|text|你需要在使用它之后释放它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2343295|下面是一个示例程序，说明了这一点。|2343296|http://forums.devx.com/showthread.php?145311-Free-memory-or-garbage-in-recursion-program|offset|length|2343297|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|2G|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@$F|R|G|S|1|T]]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|E]]]]

You need to free the memory after using it.

Here is an example program that illustrates that.

<a href="http://forums.devx.com/showthread.php?145311-Free-memory-or-garbage-in-recursion-program" rel="nofollow">http://forums.devx.com/showthread.php?145311-Free-memory-or-garbage-in-recursion-program</a>

blocks|key|2065092|text|您编写的函数(代码行)存储在文本段中，当调用它时，在堆栈内存中分配一个帧，变量(静态以外)的内存也在给定帧的堆栈中分配。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2065093|递归函数没有区别，它的正规函数也被称为n次函数。因此，它的内存(帧)也在堆栈n次上分配。|2065094|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|$]]

Functions (lines of code) you wrote are stored in text segment and when it is called it is allocated a frame in the stack memory, memory for variables (other than static) are also allocated in the stack in the given frame. 

Recursive functions are no different its also normal functions which gets called n number of times. so its memory(frame) are also allocated on the stack n number of times.

blocks|key|2343415|text|当一个函数被调用时，它沿着其他函数状态的参数保存在Stack上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2343416|在函数调用期间构造的堆栈帧包含以下内容：|2343417|函数参数|unordered-list-item|2343418|函数的返回地址。|2343419|帧指针|2343420|异常处理程序框架|2343421|本地声明的变量。|2343422|缓冲器。|2343423|Callee保存寄存器。|2343424|entityMap^0|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|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|X|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|Y|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Z|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|10|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|11|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|12|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|T|$]]

When a function is called it's parameters along other function states are saved on Stack.

Stack frame constructed during the function call contains the following:

<ul>
<li>Function parameters.</li>
<li>Function’s return address.</li>
<li>Frame pointer.</li>
<li>Exception Handler frame.</li>
<li>Locally declared variables.</li>
<li>Buffer.</li>
<li>Callee save registers.</li>
</ul>

How is memory allocated when recursive functions are called?
A function has it's own allocated memory. When it is called, the parameters (not reference-passed ones) and variables get memory. So when the function is called again from within it's body, how is memory allocated to the variables and parameters of the second call?

Memory Allocation for Recursive Functions

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

调用递归函数时如何分配内存？一个函数有它自己分配的内存。当调用它时，参数(而不是引用传递的参数)和变量将获得内存。因此，当函数从其体内再次调用时，内存是如何分配给第二个调用的变量和参数的？

问递归函数的内存分配
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问递归函数的内存分配EN