recursion and function implementation cs-2301 d-term 20091 recursion and implementation of functions...

Recursion and Function Implementation

CS-2301 D-term 2009 1

Recursion and Implementation of Functions

CS-2301 System Programming C-term 2009

(Slides include materials from The C Programming Language, 2nd edition, by Kernighan and Ritchie and from C: How to Program, 5th and 6th editions, by Deitel and Deitel)


CS-2301 D-term 2009 2

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


CS-2301 D-term 2009 3

Simplest Example

int factorial(int x) {

if (x <= 1)

return 1;

else

return x * factorial (x-1);

} // factorial


CS-2301 D-term 2009 4

Simplest Example (continued)


if (x <= 1)

return 1;

else


} // factorial • This puts the current execution of factorial “on hold” and starts a new one

• With a new argument!


CS-2301 D-term 2009 5

Simplest Example (continued)


if (x <= 1)

return 1;

else


} // factorial • When factorial(x-1) returns, its result it multiplied by x

• Mathematically:– x! = x (x-1)!


CS-2301 D-term 2009 6

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


CS-2301 D-term 2009 7

Simplest Example


if (x <= 1)

return 1;

else


} // factorial

This if statement “breaks” the recursion


CS-2301 D-term 2009 8

Questions?


CS-2301 D-term 2009 9

More Interesting ExampleTowers 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


CS-2301 D-term 2009 10

Tower of Hanoi Program

#include <stdio.h>

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


CS-2301 D-term 2009 11


#include <stdio.h>



move (n, 1, 3, 2);

return 0;} // main



*/


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


CS-2301 D-term 2009 12


#include <stdio.h>



move (n, 1, 3, 2);

return 0;} // main



*/


if (disks > 0){ move (disks-1, a, c, b); printf ("Move one disk "

"from %d to %d\n",a,c);


return;} // move

The function move – where the action is


CS-2301 D-term 2009 13


#include <stdio.h>



move (n, 1, 3, 2);

return 0;} // main



*/





return;} // move

First move all but one of the disks to temporary peg


CS-2301 D-term 2009 14


#include <stdio.h>



move (n, 1, 3, 2);

return 0;} // main



*/





return;} // move

Next, move the remaining disk to the destination peg


CS-2301 D-term 2009 15


#include <stdio.h>



move (n, 1, 3, 2);

return 0;} // main



*/





return;} // move

Finally, move disks from temporary to destination peg


CS-2301 D-term 2009 16


#include <stdio.h>



move (n, 1, 3, 2);

return 0;} // main



*/





return;} // move

Notice that move calls itself twice, but with one fewer disks each time


CS-2301 D-term 2009 17

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)


CS-2301 D-term 2009 18

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


CS-2301 D-term 2009 19

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


CS-2301 D-term 2009 20

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


CS-2301 D-term 2009 21

Questions?


CS-2301 D-term 2009 22

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.


CS-2301 D-term 2009 23

• 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


CS-2301 D-term 2009 24

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 linkerint i = b; //automaticdouble g; //automaticstatic 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( … )


CS-2301 D-term 2009 25

Static Variable Examples (continued)






} // int fcn( … )

Declaration outside any

function:– always static

static storage class:– not

visible to linker


CS-2301 D-term 2009 26







} // int fcn( … )

Inside f

unction:– defa

ult is

automati

c

static

storag

e clas

s:– not

visible

to linker


CS-2301 D-term 2009 27







} // int fcn( … )

Note: value of h is retained

from one call to next

Value of h is also retained

across recursions


CS-2301 D-term 2009 28

Extern Variables

int j; //static, visible to linker & all functsstatic float f; // not visible to linker, visible to

// to all functions in this programextern float p; // static, defined in another program



body – may access j, f, a, b, i, g, h , p

} // int fcn( … )

extern storage class:– a

static variable defined in

another C program


CS-2301 D-term 2009 29

Questions?


CS-2301 D-term 2009 30

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!


CS-2301 D-term 2009 31

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


CS-2301 D-term 2009 32

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


CS-2301 D-term 2009 33

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


CS-2301 D-term 2009 34

Typical Memory for Running Program (Windows & Linux)

0x00000000

0xFFFFFFFF

address space

program code(text)

static data

heap(dynamically allocated)

stack(dynamically allocated)

PC

SP


CS-2301 D-term 2009 35

Typical Memory for Running Program (Windows & Linux)

0x00000000

0xFFFFFFFF

address space

program code(text)

static data



PC

SP

Heap to be discussed later

in course


CS-2301 D-term 2009 36

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?


CS-2301 D-term 2009 37

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


CS-2301 D-term 2009 38

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


CS-2301 D-term 2009 39

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?


CS-2301 D-term 2009 40

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


CS-2301 D-term 2009 41

Typical Address Space (Windows & Linux)

0x00000000

0xFFFFFFFF

Memory address space

program code(text)

static data



PC

SP


CS-2301 D-term 2009 42

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.


CS-2301 D-term 2009 43

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


CS-2301 D-term 2009 44

Shared Physical Memory

OS Kernel

stack

Process 1

stack

Process 2

0x00000000

0x0000FFFF

Physical

memory

stack

Process 3


CS-2301 D-term 2009 45

Questions?


CS-2301 D-term 2009 46

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!


CS-2301 D-term 2009 47

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


CS-2301 D-term 2009 48

Tower of Hanoi Program & Use of Stack

#include <stdio.h>



move (n, 1, 3, 2);

return 0;} // main



*/





return;} // move


CS-2301 D-term 2009 49

Implementation on The Stack

nSP

Stack entry for main…


CS-2301 D-term 2009 50

Implementation on The Stack (continued)

n

SP


return address

a = 1c = 3b = 2

disks = n

Args for call to move


CS-2301 D-term 2009 51


n

SP


return address

a = 1c = 3b = 2

disks = n


return address

a = 1c = 2b = 3

disks = n-1

Args for 2nd call to move


CS-2301 D-term 2009 52


n

SP


return address

a = 1c = 3b = 2

disks = n


return address

a = 1c = 2b = 3

disks = n-1


Args for subsequent calls to move go here


CS-2301 D-term 2009 53


n

SP


return address

a = 1c = 3b = 2

disks = n


return address

a = 1c = 2b = 3

disks = n-1


Eventually, disks = 0, so no more calls to moveAll existing calls return


CS-2301 D-term 2009 54


n

SP


return address

a = 1c = 3b = 2

disks = n


Leaving stack like this again


CS-2301 D-term 2009 55


#include <stdio.h>



move (n, 1, 3, 2);

return 0;} // main



*/





return;} // move


CS-2301 D-term 2009 56


n

SP


return address

a = 1c = 3b = 2

disks = n


move now moves one disk from peg1 to peg3, and then calls move again!


CS-2301 D-term 2009 57


n

SP


return address

a = 1c = 3b = 2

disks = n


return address

a = 3c = 2b = 1

disks = n-1

Args for call to move disks back from peg3 to peg2


CS-2301 D-term 2009 58


n

SP


return address

a = 1c = 3b = 2

disks = n


return address

a = 3c = 2b = 1

disks = n-1

Args for call to move back

Args for subsequent calls to move back go here


CS-2301 D-term 2009 59


n

SP


return address

a = 1c = 3b = 2

disks = n


return address

a = 3c = 2b = 1

disks = n-1


Eventually, disks = 0, so no more calls to moveAll existing calls return


CS-2301 D-term 2009 60


n

SP


return address

a = 1c = 3b = 2

disks = n


Leaving stack like this again, but with all disks moved to peg 3


CS-2301 D-term 2009 61

Implementation on The Stack

nSP


move returns back to main


CS-2301 D-term 2009 62

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!


CS-2301 D-term 2009 63

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 toint factorial(int n) {int product = 1;

for (int k=1; k <= n; k++)

product *= k;return product

} //factorial


CS-2301 D-term 2009 64

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!


CS-2301 D-term 2009 65

Questions?

recursion and function implementation cs-2301 d-term 20091 recursion and implementation of functions...

Documents