The relationship between function recursion and stack

First, through the anti-assembly language, let's look at the simplest recursive function and the relationship between the stack.

How to get anti-assembly language, in Visual Studio 2008, in the debug environment, you can view the post-disassembly languages in debug/windows/disassembly. Now let's take a look at factorial n! The implementation

Its C language implementation code is as follows

[CPP]View Plaincopy

2. #include <stdio.h>
4. int factorial (int n);
6. int main (void)
8. {
10. int fact;
12. Fact = factorial (4);
14. printf ("%d\n", fact);
16. return 0;
18. }
20. int factorial (int n)
22. {
24. if (1 = = N)
26. return 1;
28. return n * factorial (n-1);
32. }

The following languages are disassembled:

Main program Main

[Plain]View Plaincopy

2. int main (void)
4. {
6. 00DB1FD0 Push EBP
8. 00DB1FD1 mov Ebp,esp
10. 00db1fd3 Sub Esp,0cch
12. 00DB1FD9 push EBX
14. 00DB1FDA push ESI
16. 00db1fdb Push EDI
18. 00DB1FDC Lea EDI,[EBP-0CCH]
20. 00DB1FE2 mov ecx,33h
22. 00DB1FE7 mov eax,0cccccccch
24. 00DB1FEC Rep STOs dword ptr Es:[edi]
26. int fact;
28. Fact = factorial (4);
30. 00db1fee Push 4
32. 00DB1FF0 call @ILT +475 (_factorial) (0db11e0h)
34. 00db1ff5 Add esp,4
36. 00DB1FF8 mov dword ptr [Fact],eax
38. printf ("%d\n", fact);
40. 00DB1FFB mov Esi,esp
42. 00DB1FFD mov eax,dword ptr [fact]
44. 00db2000 push EAX
46. 00db2001 Push offset string "%d\n" (0db5a38h)
48. 00db2006 call DWORD ptr [__imp__printf (0DB82BCH)]
50. 00db200c Add esp,8
52. 00DB200F CMP ESI,ESP
54. 00db2011 call @ILT +320 (__RTC_CHECKESP) (0db1145h)
56. return 0;

The assembly of its factorial function is as follows

[Plain]View Plaincopy

2. int factorial (int n)
4. {
6. 00DB1AF0 Push EBP
8. 00DB1AF1 mov Ebp,esp
10. 00db1af3 Sub esp,0c0h
12. 00DB1AF9 push EBX
14. 00db1afa push ESI
16. 00DB1AFB Push EDI
18. 00DB1AFC Lea EDI,[EBP-0C0H]
20. 00DB1B02 mov ecx,30h
22. 00DB1B07 mov eax,0cccccccch
24. 00DB1B0C Rep STOs dword ptr Es:[edi]
26. if (1 = = N)
28. 00DB1B0E cmp DWORD ptr [n],1
30. 00DB1B12 jne factorial+2bh (0DB1B1BH)
32. return 1;
34. 00DB1B14 mov eax,1
36. 00db1b19 jmp Factorial+3eh (0db1b2eh)
38. return n * factorial (n-1);
40. 00DB1B1B mov Eax,dword ptr [n]
42. 00db1b1e Sub eax,1
44. 00DB1B21 push EAX
46. 00db1b22 call @ILT +475 (_factorial) (0db11e0h)
48. 00db1b27 Add esp,4
50. 00DB1B2A Imul Eax,dword ptr [n]
54. }
56. 00DB1B2E Pop EDI
58. 00DB1B2F pop ESI
60. 00db1b30 pop ebx
62. 00db1b31 Add esp,0c0h
64. 00DB1B37 CMP EBP,ESP
66. 00db1b39 call @ILT +320 (__RTC_CHECKESP) (0db1145h)
68. 00DB1B3E mov esp,ebp
70. 00DB1B40 Pop EBP
72. 00DB1B41 ret

Throughout the assembly, the

[Plain]View Plaincopy

1. Call @ILT +475 (_factorial) (0db11e0h)

The previous push is the stack of arguments. Here is the key, the other push we can think of is the system for the balance of the stack of necessary operations.

In the disassembly of factorial,

[Plain]View Plaincopy

1. 00db1b39 call @ILT +320 (__RTC_CHECKESP) (0db1145h)

This sentence is the function factorial calls itself, that is, recursion.

Push eax, save the parameters of each stack into the EAX register, and then into the stack, so in n! = 1 o'clock, each parameter will be in the stack;

[Plain]View Plaincopy

1. 00DB1B2A Imul Eax,dword ptr [n]

This step is for multiplication. Holds the multiplied value in the EAX register.

In fact, throughout the process, involving a series of operations on the stack frame in a function call, http://blog.csdn.net/free2011/article/details/6868334 this blog details a series of operations that call the stack frame during the function.

Make a summary:

function recursion is to use the stack in the system to operate, through a series of operations on the stack frame, so as to achieve recursion. This process is done by the system.

In factorial, we use the parameters of the factorial function into the stack, and then through the stack frame of a series of operations, so as to achieve the parameters of the stack, and then complete the factorial of this action. The whole process is actually a stack-up and stack-up problem.

Now we are going to implement recursive functions by defining a stack ourselves.

[CPP]View Plaincopy

2. #include "Stack.h"
4. #define Numofstack 10
6. int main (void)
8. {
10. Stacknode * Pstacknode = NULL;
12. int noffact;
14. int tmp = 1,sum = 1;
16. Pstacknode = Createstack (Numofstack);
18. printf ("The number of factorial\n");
20. scanf ("%d", &noffact);
22. While (noffact)
24. {
26. Push (pstacknode,noffact--);
28. }
30. While (pstacknode->top)
32. {
34. Pop (PSTACKNODE,&TMP);
36. Sum *= tmp;
38. }
40. printf ("sum is%d\n", sum);
42. return 0;
44. }

Only the main program section is rendered. In the main program, we first load the parameters into the stack, that is, N, n-1 、... 1 into the stack, and then out of the stack to operate.

import org.junit.Test;/** * Created by Yuchao on 2015/9/13.*/ Public classDigui {@Test Public voidHello () {DG ("Recursive initial",0); }     Public voidDG (String Dname,inti) {System. out. println ("DG ("+dname+","+i+")"); I++; if(i<4) {DG ("Upper Recursion", i); DG ("Lower level recursion", i); }Else{System. out. println ("--"); }    }}

DG (recursive initial, 0)
DG (Upper recursion, 1)
DG (Upper recursion, 2)
DG (Upper recursion, 3)
--
DG (Lower recursion, 3)
--
DG (Lower recursion, 2)
DG (Upper recursion, 3)
--
DG (Lower recursion, 3)
--
DG (Lower recursion, 1)
DG (Upper recursion, 2)
DG (Upper recursion, 3)
--
DG (Lower recursion, 3)
--
DG (Lower recursion, 2)
DG (Upper recursion, 3)
--
DG (Lower recursion, 3)
--

Process finished with exit code 0

This article is written in a more general, I would like to tell you that by watching the anti-assembly language on the recursive implementation of the process and steps of the procedure, can deepen our understanding of function recursion and stack. Although the assembly language is somewhat difficult to understand, but by reading the above for everyone to recommend blog, I believe we can understand.

The relationship between function recursion and stack