1. Recursion and Function Implementation CS-2301 D-term 20091 Recursion and Implementation of Functions CS-2301 System Programming C-term 2009 (Slides include materials from The C Programming Language, 2 nd edition, by Kernighan and Ritchie and from C: How to Program, 5 th and 6 th editions, by Deitel and Deitel)

2. Recursion and Function Implementation CS-2301 D-term 20092 Definition Recursive Function:– a function that calls itself Directly or indirectly Each recursive call is made with a new, independent set of arguments Previous calls are suspended Allows very simple programs for very complex problems

3. Recursion and Function Implementation CS-2301 D-term 20093 Simplest Example int factorial(int x) { if (x <= 1) return 1; else return x * factorial (x-1); }// factorial

4. Recursion and Function Implementation CS-2301 D-term 20094 Simplest Example (continued) int factorial(int x) { if (x <= 1) return 1; else return x * factorial (x-1); }// factorial This puts the current execution of factorial “on hold” and starts a new one With a new argument!

5. Recursion and Function Implementation CS-2301 D-term 20095 Simplest Example (continued) int factorial(int x) { if (x <= 1) return 1; else return x * factorial (x-1); }// factorial When factorial(x-1 ) returns, its result it multiplied by x Mathematically:– x! = x  (x-1)!

6. Recursion and Function Implementation CS-2301 D-term 20096 Recursion (continued) There is an obvious circularity here –factorial calls factorial calls factorial, etc. But each one is called with a smaller value for argument! –Eventually, argument becomes ≤ 1 –Invokes if clause to terminate recursion

7. Recursion and Function Implementation CS-2301 D-term 20097 Simplest Example int factorial(int x) { if (x <= 1) return 1; else return x * factorial (x-1); }// factorial This if statement “breaks” the recursion

8. Recursion and Function Implementation CS-2301 D-term 20098 Questions?

9. Recursion and Function Implementation CS-2301 D-term 20099 More Interesting Example Towers of Hanoi Move stack of disks from one peg to another Move one disk at a time Larger disk may never be on top of smaller disk

10. Recursion and Function Implementation CS-2301 D-term 200910 Tower of Hanoi Program #include void move (int disks, int a, int c, int b); int main() { int n; printf ("How many disks?"); scanf ("%d", &n); printf ("\n"); move (n, 1, 3, 2); return 0; }// main /* PRE: n >= 0; a, b, and c represent some order of the distinct integers 1, 2, 3 POST: the function displays the individual moves necessary to move n disks from needle a to needle c, using needle b as a temporary storage needle */ void move (int disks, int a, int c, int b) { if (disks > 0) { move (disks-1, a, c, b); printf ("Move one disk from %d to %d\n", a, c); move (disks-1, b, a, c); }// if (disks > 0 return; }//move

11. Recursion and Function Implementation CS-2301 D-term 200911 Tower of Hanoi Program #include void move (int disks, int a, int c, int b); int main() { int n; printf ("How many disks?"); scanf ("%d", &n); printf ("\n"); move (n, 1, 3, 2); return 0; }// main /* PRE: n >= 0; a, b, and c represent some order of the distinct integers 1, 2, 3 POST: the function displays the individual moves necessary to move n disks from needle a to needle c, using needle b as a temporary storage needle */ void move (int disks, int a, int c, int b) { if (disks > 0){ move (disks-1, a, c, b); printf ("Move one disk from %d to %d\n", a, c); move (disks-1, b, a, c); }// if (disks > 0 return; }//move The function main – gets number of disks and invokes function move

12. Recursion and Function Implementation CS-2301 D-term 200912 Tower of Hanoi Program #include void move (int disks, int a, int c, int b); int main() { int n; printf ("How many disks?"); scanf ("%d", &n); printf ("\n"); move (n, 1, 3, 2); return 0; }// main /* PRE: n >= 0; a, b, and c represent some order of the distinct integers 1, 2, 3 POST: the function displays the individual moves necessary to move n disks from needle a to needle c, using needle b as a temporary storage needle */ void move (int disks, int a, int c, int b) { if (disks > 0){ move (disks-1, a, c, b); printf ("Move one disk " "from %d to %d\n",a,c); move (disks-1, b, a, c); }// if (disks > 0 return; }//move The function move – where the action is

13. Recursion and Function Implementation CS-2301 D-term 200913 Tower of Hanoi Program #include void move (int disks, int a, int c, int b); int main() { int n; printf ("How many disks?"); scanf ("%d", &n); printf ("\n"); move (n, 1, 3, 2); return 0; }// main /* PRE: n >= 0; a, b, and c represent some order of the distinct integers 1, 2, 3 POST: the function displays the individual moves necessary to move n disks from needle a to needle c, using needle b as a temporary storage needle */ void move (int disks, int a, int c, int b) { if (disks > 0){ move (disks-1, a, c, b); printf ("Move one disk " "from %d to %d\n",a,c); move (disks-1, b, a, c); }// if (disks > 0 return; }//move First move all but one of the disks to temporary peg

14. Recursion and Function Implementation CS-2301 D-term 200914 Tower of Hanoi Program #include void move (int disks, int a, int c, int b); int main() { int n; printf ("How many disks?"); scanf ("%d", &n); printf ("\n"); move (n, 1, 3, 2); return 0; }// main /* PRE: n >= 0; a, b, and c represent some order of the distinct integers 1, 2, 3 POST: the function displays the individual moves necessary to move n disks from needle a to needle c, using needle b as a temporary storage needle */ void move (int disks, int a, int c, int b) { if (disks > 0){ move (disks-1, a, c, b); printf ("Move one disk " "from %d to %d\n",a,c); move (disks-1, b, a, c); }// if (disks > 0 return; }//move Next, move the remaining disk to the destination peg

15. Recursion and Function Implementation CS-2301 D-term 200915 Tower of Hanoi Program #include void move (int disks, int a, int c, int b); int main() { int n; printf ("How many disks?"); scanf ("%d", &n); printf ("\n"); move (n, 1, 3, 2); return 0; }// main /* PRE: n >= 0; a, b, and c represent some order of the distinct integers 1, 2, 3 POST: the function displays the individual moves necessary to move n disks from needle a to needle c, using needle b as a temporary storage needle */ void move (int disks, int a, int c, int b) { if (disks > 0){ move (disks-1, a, c, b); printf ("Move one disk " "from %d to %d\n",a,c); move (disks-1, b, a, c); }// if (disks > 0 return; }//move Finally, move disks from temporary to destination peg

16. Recursion and Function Implementation CS-2301 D-term 200916 Tower of Hanoi Program #include void move (int disks, int a, int c, int b); int main() { int n; printf ("How many disks?"); scanf ("%d", &n); printf ("\n"); move (n, 1, 3, 2); return 0; }// main /* PRE: n >= 0; a, b, and c represent some order of the distinct integers 1, 2, 3 POST: the function displays the individual moves necessary to move n disks from needle a to needle c, using needle b as a temporary storage needle */ void move (int disks, int a, int c, int b) { if (disks > 0){ move (disks-1, a, c, b); printf ("Move one disk " "from %d to %d\n",a,c); move (disks-1, b, a, c); }// if (disks > 0 return; }//move Notice that move calls itself twice, but with one fewer disks each time

17. Recursion and Function Implementation CS-2301 D-term 200917 Why Recursion? Not often used by programmers with ordinary skills in some areas, but … … some problems are too hard to solve without recursion –Most notably, the compiler! –Tower of Hanoi problem –Most problems involving linked lists and trees (Later in the course)

18. Recursion and Function Implementation CS-2301 D-term 200918 Recursion vs. Iteration Some simple recursive problems can be “unwound” into loops But code becomes less compact, harder to follow! Hard problems cannot easily be expressed in non-recursive code Tower of Hanoi Robots or avatars that “learn” Advanced games

19. Recursion and Function Implementation CS-2301 D-term 200919 Recursion is so important … … that all modern computer architectures specifically support it Stack register Instructions for manipulating The Stack … most modern programming languages allow it But not Fortran and not Cobol

20. Recursion and Function Implementation CS-2301 D-term 200920 Personal Observation From my own experience, programming languages and environments that do not support recursion … … are usually not rich enough to support a diverse portfolio of programs I.e., a wide variety of applications in many different disciplines

21. Recursion and Function Implementation CS-2301 D-term 200921 Questions?

22. Recursion and Function Implementation CS-2301 D-term 200922 Data Storage in Memory Variables may be automatic or static Automatic variables may only be declared within functions and compound statements (blocks) Storage allocated when function or block is entered Storage is released when function returns or block exits Parameters and result are (somewhat) like automatic variables Storage is allocated and initialized by caller of function Storage is released after function returns to caller.

23. Recursion and Function Implementation CS-2301 D-term 200923 Static variables may be declared within or outside of functions Storage allocated when program is initialized Storage is released when program exits Static variables outside of functions may be visible to linker Compiler sets aside storage for all static variables at compiler or link time Values retained across function calls Initialization must evaluate to compile-time constant Static Data

24. Recursion and Function Implementation CS-2301 D-term 200924 Static Variable Examples int j;//static, visible to linker & all functs static float f; // not visible to linker, visible to // to all functions in this program int fcn (float a, int b) { // nothing inside of {} is visible to linker int i = b;//automatic double g;//automatic static double h;//static, not visible to // linker; value retained from call to call body – may access j, f, a, b, i, g, h }//int fcn( … )

25. Recursion and Function Implementation CS-2301 D-term 200925 Static Variable Examples (continued) int j;//static, visible to linker & all functs static float f; // not visible to linker, visible to // to all functions in this program int fcn (float a, int b) { // nothing inside of {} is visible to linker int i = b;//automatic double g;//automatic static double h;//static, not visible to // linker; value retained from call to call body – may access j, f, a, b, i, g, h }//int fcn( … ) Declaration outside any function:– always static static storage class:– not visible to linker

26. Recursion and Function Implementation CS-2301 D-term 200926 Static Variable Examples (continued) int j;//static, visible to linker & all functs static float f; // not visible to linker, visible to // to all functions in this program int fcn (float a, int b) { // nothing inside of {} is visible to linker int i = b;//automatic double g;//automatic static double h;//static, not visible to // linker; value retained from call to call body – may access j, f, a, b, i, g, h }//int fcn( … ) Inside function:– default is automatic static storage class:– not visible to linker

27. Recursion and Function Implementation CS-2301 D-term 200927 Static Variable Examples (continued) int j;//static, visible to linker & all functs static float f; // not visible to linker, visible to // to all functions in this program int fcn (float a, int b) { // nothing inside of {} is visible to linker int i = b;//automatic double g;//automatic static double h;//static, not visible to // linker; value retained from call to call body – may access j, f, a, b, i, g, h }//int fcn( … ) Note: value of h is retained from one call to next Value of h is also retained across recursions

28. Recursion and Function Implementation CS-2301 D-term 200928 Extern Variables int j;//static, visible to linker & all functs static float f; // not visible to linker, visible to // to all functions in this program extern float p; // static, defined in another program int fcn (float a, int b) { // nothing inside of {} is visible to linker int i = b;//automatic double g;//automatic static double h;//static, not visible to // linker; value retained from call to call body – may access j, f, a, b, i, g, h, p }//int fcn( … ) extern storage class:– a static variable defined in another C program

29. Recursion and Function Implementation CS-2301 D-term 200929 Questions?

30. Recursion and Function Implementation CS-2301 D-term 200930 Automatic Variables, Arguments, & Results Allocated on The Stack Definition – The Stack –A last-in, first-out data structure provided by the operating system for each running program –For temporary storage of automatic variables, arguments, function results, and other stuff Used by all modern programming languages –Even assembly languages for modern processors –… but not Fortran or Cobol!

31. Recursion and Function Implementation CS-2301 D-term 200931 Automatic Variables Allocated when function or compound statement is entered Released when function or compound statement is exited Values not retained from execution to next

32. Recursion and Function Implementation CS-2301 D-term 200932 Arguments and Results Arguments are values calculated by caller of function Placed on The Stack by caller for use by function Function may assign new value to argument, but … …caller never looks at argument values again! Result is storage allocated by caller On The Stack Assigned by return statement of function For use by caller Arguments & result are removed by caller After function returns, after caller has absorbed return value

33. Recursion and Function Implementation CS-2301 D-term 200933 Typical Implementation of The Stack Linear region of memory Stack Pointer “growing” downward Each time some information is pushed onto The Stack, pointer moves downward Each time info is popped off of The Stack, pointer moves back upward

34. Recursion and Function Implementation CS-2301 D-term 200934 Typical Memory for Running Program (Windows & Linux) 0x00000000 0xFFFFFFFF address space program code (text) static data heap (dynamically allocated) stack (dynamically allocated) PC SP

35. Recursion and Function Implementation CS-2301 D-term 200935 Typical Memory for Running Program (Windows & Linux) 0x00000000 0xFFFFFFFF address space program code (text) static data heap (dynamically allocated) stack (dynamically allocated) PC SP Heap to be discussed later in course

36. Recursion and Function Implementation CS-2301 D-term 200936 How it works Imagine the following program:– int factorial(int n){ … /* body of factorial function */ … }// factorial Imagine also the caller:– int x = factorial(100); What does compiled code look like?

37. Recursion and Function Implementation CS-2301 D-term 200937 Compiled code: the caller int x = factorial(100); Put the value “100” somewhere that factorial function can find Put the current program counter somewhere so that factorial function can return to the right place in calling function Provide a place to put the result, so that calling function can find it

38. Recursion and Function Implementation CS-2301 D-term 200938 Compiled code: factorial function Save the caller’s registers somewhere Get the argument n from the agreed-upon place Set aside some memory for local variables and intermediate results Do whatever factorial was programmed to do Put the result where the caller can find it Restore the caller’s registers Transfer back to the program counter saved by the caller

39. Recursion and Function Implementation CS-2301 D-term 200939 Question: Where is “somewhere”? So that caller can provide as many arguments as needed (within reason)? So that called routine can decide at run-time how much temporary space is needed? So that called routine can call any other routine, potentially recursively?

40. Recursion and Function Implementation CS-2301 D-term 200940 Answer: The Stack Calling function Push space for result, and arguments onto stack Push return address and Jump to called function Called function Push registers and automatic storage space onto stack Do work of the routine, store result in space pushed above Pop registers and automatic storage off stack Jump to return address left by calling routine

41. Recursion and Function Implementation CS-2301 D-term 200941 Typical Address Space (Windows & Linux) 0x00000000 0xFFFFFFFF Memory address space program code (text) static data heap (dynamically allocated) stack (dynamically allocated) PC SP

42. Recursion and Function Implementation CS-2301 D-term 200942 Note Through the magic of operating systems, each running program has its own memory –Complete with stack & everything else Called a process Windows, Linux, Unix, etc.

43. Recursion and Function Implementation CS-2301 D-term 200943 Note (continued) Not necessarily true in small, embedded systems Real-time & control systems Mobile phone & PDA Remote sensors, instrumentation, etc. Multiple running programs share a memory Each in own partition with own stack Barriers to prevent each from corrupting others

44. Recursion and Function Implementation CS-2301 D-term 200944 Shared Physical Memory OS Kernel stack Process 1 stack Process 2 0x00000000 0x0000FFFF Physical memory stack Process 3

45. Recursion and Function Implementation CS-2301 D-term 200945 Questions?

46. Recursion and Function Implementation CS-2301 D-term 200946 Why a Stack? Engineering reason – Computer architectures without stacks are not “rich” enough to support demands of modern computing Multiple running programs at the same time Complex interactions among running programs Modern computer languages Mathematical reason – To support recursive programs Not often used by programmers with ordinary skills, but … Some problems are too hard to solve without recursion Most notably, the compiler!

47. Recursion and Function Implementation CS-2301 D-term 200947 Why a Stack? Engineering reason – Computer architectures without stacks are not “rich” enough to support demands of modern computing Multiple running programs at the same time Complex interactions among running programs Modern computer languages Mathematical reason – To support recursive programs Not often used by programmers with ordinary skills, but … Some problems are too hard to solve without it Also, advanced games and robotics with “intelligent” objects

48. Recursion and Function Implementation CS-2301 D-term 200948 Tower of Hanoi Program & Use of Stack #include void move (int disks, int a, int c, int b); int main() { int n; printf ("How many disks?"); scanf ("%d", &n); printf ("\n"); move (n, 1, 3, 2); return 0; }// main /* PRE: n >= 0; a, b, and c represent some order of the distinct integers 1, 2, 3 POST: the function displays the individual moves necessary to move n disks from needle a to needle c, using needle b as a temporary storage needle */ void move (int disks, int a, int c, int b) { if (disks > 0){ move (disks-1, a, c, b); printf ("Move one disk " "from %d to %d\n",a,c); move (disks-1, b, a, c); }// if (disks > 0 return; }//move

49. Recursion and Function Implementation CS-2301 D-term 200949 Implementation on The Stack n SP Stack entry for main …

50. Recursion and Function Implementation CS-2301 D-term 200950 Implementation on The Stack (continued) n SP Stack entry for main … return address a = 1 c = 3 b = 2 disks = n Args for call to move

51. Recursion and Function Implementation CS-2301 D-term 200951 Implementation on The Stack (continued) n SP Stack entry for main … return address a = 1 c = 3 b = 2 disks = n Args for call to move return address a = 1 c = 2 b = 3 disks = n-1 Args for 2 nd call to move

52. Recursion and Function Implementation CS-2301 D-term 200952 Implementation on The Stack (continued) n SP Stack entry for main … return address a = 1 c = 3 b = 2 disks = n Args for call to move return address a = 1 c = 2 b = 3 disks = n-1 Args for 2 nd call to move Args for subsequent calls to move go here

53. Recursion and Function Implementation CS-2301 D-term 200953 Implementation on The Stack (continued) n SP Stack entry for main … return address a = 1 c = 3 b = 2 disks = n Args for call to move return address a = 1 c = 2 b = 3 disks = n-1 Args for 2 nd call to move Eventually, disks = 0, so no more calls to move All existing calls return

54. Recursion and Function Implementation CS-2301 D-term 200954 Implementation on The Stack (continued) n SP Stack entry for main … return address a = 1 c = 3 b = 2 disks = n Args for call to move Leaving stack like this again

55. Recursion and Function Implementation CS-2301 D-term 200955 Tower of Hanoi Program #include void move (int disks, int a, int c, int b); int main() { int n; printf ("How many disks?"); scanf ("%d", &n); printf ("\n"); move (n, 1, 3, 2); return 0; }// main /* PRE: n >= 0; a, b, and c represent some order of the distinct integers 1, 2, 3 POST: the function displays the individual moves necessary to move n disks from needle a to needle c, using needle b as a temporary storage needle */ void move (int disks, int a, int c, int b) { if (disks > 0){ move (disks-1, a, c, b); printf ("Move one disk " "from %d to %d\n",a,c); move (disks-1, b, a, c); }// if (disks > 0 return; }//move

56. Recursion and Function Implementation CS-2301 D-term 200956 Implementation on The Stack (continued) n SP Stack entry for main … return address a = 1 c = 3 b = 2 disks = n Args for call to move move now moves one disk from peg1 to peg3, and then calls move again!

57. Recursion and Function Implementation CS-2301 D-term 200957 Implementation on The Stack (continued) n SP Stack entry for main … return address a = 1 c = 3 b = 2 disks = n Args for call to move return address a = 3 c = 2 b = 1 disks = n-1 Args for call to move disks back from peg3 to peg2

58. Recursion and Function Implementation CS-2301 D-term 200958 Implementation on The Stack (continued) n SP Stack entry for main … return address a = 1 c = 3 b = 2 disks = n Args for call to move return address a = 3 c = 2 b = 1 disks = n-1 Args for call to move back Args for subsequent calls to move back go here

59. Recursion and Function Implementation CS-2301 D-term 200959 Implementation on The Stack (continued) n SP Stack entry for main … return address a = 1 c = 3 b = 2 disks = n Args for call to move return address a = 3 c = 2 b = 1 disks = n-1 Args for 2 nd call to move Eventually, disks = 0, so no more calls to move All existing calls return

60. Recursion and Function Implementation CS-2301 D-term 200960 Implementation on The Stack (continued) n SP Stack entry for main … return address a = 1 c = 3 b = 2 disks = n Args for call to move Leaving stack like this again, but with all disks moved to peg 3

61. Recursion and Function Implementation CS-2301 D-term 200961 Implementation on The Stack n SP Stack entry for main … move returns back to main

62. Recursion and Function Implementation CS-2301 D-term 200962 Fundamental Principle Stack provides a simple mechanism for implementing recursive functions Arbitrary numbers of intermediate functions Eventually, something must break the circularity of recursion Or stack will grow until it overflows memory!

63. Recursion and Function Implementation CS-2301 D-term 200963 Note on Recursive Functions Some simple recursive functions can be “unwound” into loops – e.g., int factorial(int n) { return (n <= 1) ? 1 : (n * factorial(n-1)); }//factorial is equivalent to int factorial(int n) { int product = 1; for (int k=1; k <= n; k++) product *= k; return product } //factorial

64. Recursion and Function Implementation CS-2301 D-term 200964 Note on Recursive Functions (continued) Other recursive functions are much too difficult to understand if unwound E.g., Tower of Hanoi Keeping track of which disk is on which peg requires superhuman intellect, very complex code!

65. Recursion and Function Implementation CS-2301 D-term 200965 Questions?