1

Functions

(covered by Chapter 5 in ABC)

2

Type function_name( parameter list )

{

Declarations

Statements

}

Function Definition

HeaderHeader

bodybody

Partitioning the code into functions makes it more readable and self-documenting

3

Runtime Stackreturn value

actual parameters

f2() control link

activation saved machine status

record local data

temporaries

return value

actual parameters

f1() control link

activation saved machine status

record local data

temporaries

return value

actual parameters

main() control link

activation saved machine status

record local data

temporaries

Activation records / stack frames are created and stored in an area of memory termed the runtime stack.

Activation records / stack frames are created and stored in an area of memory termed the runtime stack.

void f2(char c, int i){...

}void f1(int i){

...f2('a', i);...

}int main(void){

f1(1);return 0;

}

4

Storage Organization• The program stack grows each

time a function call is made.

• Infinite recursion results in a collision between the runtime stack and the heap termed a run-time stack overflow error.

• Illegal pointer de-references (garbage, dangling-references) often result in memory references outside the operating system allocated partition, (segment) for the C program resulting in a segmentation error (GPF - access violation) and core dump.

System Privileges

(not accessible to the C program)

Binary Code

Static Data

Runtime Stack

Function activation

record management

Dynamic memory

structure management

Heap

Typical C program execution memory model Typical C program execution memory model

5

double abs_value( double x )

{

if ( x >= 0.0 )

return x;

else

return -x;

}

•Conversions

•No use of return value

•The stack mechanism

The return statement

The evaluated value is returnedThe evaluated value is returned

return;return ++a;return (a * b);

6

double sqrt( double );

void f(char c, int i);

is equivalent to:

void f(char, int);

Function Prototypes

When declaring a function, the names of the input parameters do not matter, only their type and order.

When declaring a function, the names of the input parameters do not matter, only their type and order.

7

#include <stdio.h>

#define N 7

long power( int, int );

void prn_heading( void );

void prn_tbl_of_powers( int );

int main(void)

{

prn_heading();

prn_tbl_of_powers( N );

return 0;

}

Functions Example

Function declaration (Prototypes)

Function declaration (Prototypes)

Using the functionsUsing the functions

8

Functions Examplevoid prn_heading( void )

{

printf( “\n::::: A TABLE OF POWERS :::::\n\n” );

}

long power( int m, int n)

{

int i = 0;

long product = 1;

for ( i = 1; i <= n; ++i )

product *= m;

return product;

}

9

Functions Examplevoid prn_tbl_of_powers( int n )

{

int i = 0, j = 0;

for ( i = 1; i <= n; ++i )

{

for ( j = 1; j <= n; ++j )

{

if ( j == 1 )

printf( “%ld”, power( i, j ) );

else

printf( “%9ld”, power( i, j ) );

}

putchar( ‘\n’ );

}

}

::::: A TABLE OF POWERS :::::

1 1 1 1 1 1 1

2 4 8 16 32 64 128

3 9 27 81 243 729 2187

…..

10

#include <stdio.h>

int main( void )

{

int n = 3, sum = 0, compute_sum( int );

printf( “%d\n”, n );

sum = compute_sum( n );

printf( “%d\n”, n );

printf( “%d\n”, sum );

return 0;

}

what happens to n and sum here?what happens to n and sum here?

Call by Value

Function declarationFunction declaration

3 is printed3 is printed

3 is printed3 is printed

6 is printed6 is printed

11

Call by Value

int compute_sum( int n ) {

int sum = 0;

for ( ; n > 0; --n ) sum += n;return sum;

}

sum the integers from 1 to nsum the integers from 1 to n

This n is local. It gets the value of the of the varuable that was sent to the function.

This n is local. It gets the value of the of the varuable that was sent to the function.

sum is local to the function and.sum is local to the function and.

local n and sum are changedlocal n and sum are changed

12

Function invocation - summary

1. Each expression in the argument list is evaluated.

2. The value of the expression is converted, if necessary, to the type of the formal parameter, and is assigned to its corresponding formal parameter ("call by value") at the beginning of the function's body.

3. The body of the function is executed.

4. If a 'return' statement is executed, then control is passed back to the calling environment.

5. If the 'return' statement includes an expression then the value of the expression is converted, if necessary, to the type given by the type specifier of the function, and that value is passed to the calling environment as well.

6. If the 'return' statement does not include an expression, no useful value is returned.

7. If no 'return' statement is present, control is passed back to the calling environment at the end of the function's body. No useful value is returned.

13

#includes#defineslist of prototypes

#include “pgm.h” #include “pgm.h” #include “pgm.h”

main.c fct.c prn.c

pgm.h

Developing large programs

gcc -g -ansi -pedantic-errors main.c fct.c prn.c -o pgmgcc -g -ansi -pedantic-errors main.c fct.c prn.c -o pgm

14

fct.c#include "pgm.h”

void fct1( int n )

{

int i = 0;

printf( “Hello from fct1()\n” );

for ( i = 0; i < n; ++i )

fct2();

}

void fct2( void )

{

printf( “Hello from fct2()\n” );

}

15

main.c#include "pgm.h"

int main( void )

{

char ans = 0;

int i = 0, n = N;

printf( “%s”, “This program does not do very much.\n”

“Do you want more information? ”);

scanf( “ %c”, &ans );

if ( ans == ‘y’ || ans == ‘Y’ )

prn_info( “pgm” );

for ( i = 0; i < n; ++i )

fct1( i );

printf( “Bye!\n” );

return 0;

}

16

pgm.h

#include <stdio.h>

#include <stdlib.h>

#define N 3

void fct1(int k);

void fct2(void);

void prn_info(char *);

17

prn.c#include "pgm.h"

void prn_info( char *pgm_name )

{

printf( “Usage: %s\n\n”, pgm_name );

printf( “%s\n”, “This program illustrates how one can write a program\n”

“in more than one file. In this example, we have a\n”

“single .h file that gets included at the top of our\n”

“three .c files. Thus the .h file acts as the \“glue\”\n”

“that binds the program together.\n\n”

“Note that the functions fct1() and fct2() when called\n”

“only say \“hello.\” When writing a serious program, the\n”

“programmer sometimes does this in a first working\n”

“version of the code.\n” );

}

18

Assertions#include <assert.h>

#include <stdio.h>

int f( int a, int b );

int g( int c );

int main( void )

{

int a = 0, b = 0, c = 0;

....

scanf( “%d%d”, &a, &b );

.....

c = f( a,b );

assert( c > 0 );

.....

}

an assertion: used to enforce certain logical conditionsan assertion: used to enforce certain logical conditions

19

Assertions

int f( int a, int b )

{

.....

assert( a == 1 || a == -1 );

assert( b >= 7 && b <== 11 );

......

}

The assertion makes sure that the statement evaluates to true

The assertion makes sure that the statement evaluates to true

20

Scope Rules{

int a = 1, b = 2, c = 3;

printf( “%3d%3d%3d\n”, a, b, c );

{

int b = 4;

float c = 5.0;

printf( “%3d%3d%5.1f\n”, a, b, c );

a = b;

{

int c;

c = b;

printf( “%3d%3d%3d\n”, a, b, c );

}

printf( “%3d%3d%5.1f\n”, a, b, c );

}

printf( “%3d%3d%3d\n”, a, b, c );

}

What is the output of this code?

21

Scope Rules{

int a = 1, b = 2, c = 3;

printf( “%3d%3d%3d\n”, a, b, c );

{

int b = 4;

float c = 5.0;

printf( “%3d%3d%5.1f\n”, a, b, c );

a = b;

{

int c;

c = b;

printf( “%3d%3d%3d\n”, a, b, c );

}

printf( “%3d%3d%5.1f\n”, a, b, c );

}

printf( “%3d%3d%3d\n”, a, b, c );

}

1 2 31 2 3

1 4 5.01 4 5.0

4 4 44 4 4

4 4 5.04 4 5.0

4 2 34 2 3