Functions

Prof. Indranil Sen Gupta

Dept. of Computer Science & Engg.
Indian Institute of Technology
Kharagpur
 Introduction

• Function
– A self-contained program segment that carries out some
specific, well-defined task.
• Some properties:
– Every C program consists of one or more functions.
• One of these functions must be called “main”.
• Execution of the program always begins by carrying out the
instructions in “main”.
– A function will carry out its intended action whenever it
is called or invoked.

Autumn Semester 2019 Programming and Data Structure 2

 – In general, a function will process information that is
passed to it from the calling portion of the program,
and return a single value.
• Information is passed to the function via special identifiers
called arguments or parameters.
• The value is returned by the “return” statement.
– Some function may not return anything.
• Return data type specified as “void”.

Autumn Semester 2019 Programming and Data Structure 3

#include <stdio.h>

int factorial (int m) Output:

{ 1! = 1
int i, temp=1; 2! = 2
for (i=1; i<=m; i++) 3! = 6
4! = 24
temp = temp * i; 5! = 120
return (temp); 6! = 720
} 7! = 5040
8! = 40320
9! = 362880
int main() 10! = 3628800
{
int n;
for (n=1; n<=10; n++)
printf (ʺ%d! = %d \nʺ,
n, factorial (n));
return 0;
}
Autumn Semester 2019 Programming and Data Structure 4
#include <stdio.h>

int factorial (int m) Output:

{ 11! = 39916800
int i, temp=1; 12! = 479001600
for (i=1; i<=m; i++) 13! = 1932053504
14! = 1278945280
temp = temp * i; 15! = 2004310016
return (temp); 16! = 2004189184
} 17! = -288522240
18! = -898433024
19! = 109641728
int main() 20! = -2102132736
{
int n;
for (n=11; n<=20; n++)
printf (ʺ%d! = %d \nʺ,
n, factorial (n));
return 0;
}
Autumn Semester 2019 Programming and Data Structure 5
#include <stdio.h>

long int factorial (int m) Output:

{ 11! = 39916800
int i; long int temp=1; 12! = 479001600
for (i=1; i<=m; i++) 13! = 6227020800
14! = 87178291200
temp = temp * i; 15! = 1307674368000
return (temp); 16! = 20922789888000
} 17! = 355687428096000
18! = 6402373705728000
19! = 121645100408832000
int main() 20! = 2432902008176640000
{
int n;
for (n=11; n<=20; n++)
printf (ʺ%d! = %ld \nʺ,
n, factorial (n));
return 0;
}
Autumn Semester 2019 Programming and Data Structure 6
 Why Functions?

• Functions
– Allows one to develop a program in a modular fashion.
• Divide-and-conquer approach.
– All variables declared inside functions are local variables.
• Known only in function defined.
• There are exceptions (to be discussed later).
– Parameters
• Communicate information between functions.
• They also become local variables.

Autumn Semester 2019 Programming and Data Structure 7

• Benefits
– Divide and conquer
• Manageable program development.
• Construct a program from small pieces or components.

– Software reusability
• Use existing functions as building blocks for new programs.
• Abstraction: hide internal details (library functions).

Autumn Semester 2019 Programming and Data Structure 8

 Defining a Function

• A function definition has two parts:

– The first line.
– The body of the function.

return-value-type function-name (parameter-list )

{
declarations and statements
}

Autumn Semester 2019 Programming and Data Structure 9

• The first line contains the return-value-type, the function name, and
optionally a set of comma-separated arguments enclosed in
parentheses.
– Each argument has an associated type declaration.
– The arguments are called formal arguments or formal parameters.
• Example:
int gcd (int A, int B)

• The argument data types can also be declared on the next line:
int gcd (A, B)
int A, B;

Autumn Semester 2019 Programming and Data Structure 10

• The body of the function is actually a compound
statement that defines the action to be taken by the
function.

int gcd (int A, int B)

{
int temp;
while ((B % A) != 0) {
temp = B % A;
BODY
B = A;
A = temp;
}
return A;
}
Autumn Semester 2019 Programming and Data Structure 11
• When a function is called from some other function, the
corresponding arguments in the function call are called
actual arguments or actual parameters.
– The formal and actual arguments must match in their
data types.
• Point to note:
– The identifiers used as formal arguments are “local”.
• Not recognized outside the function.
• Names of formal and actual arguments may differ.

Autumn Semester 2019 Programming and Data Structure 12

 #include <stdio.h>
/* Compute the GCD of four numbers */

int main()
{
int n1, n2, n3, n4, result;
scanf (ʺ%d %d %d %dʺ, &n1, &n2, &n3, &n4);
result = gcd ( gcd (n1, n2), gcd (n3, n4) );
printf (ʺThe GCD of %d, %d, %d and %d is %d \nʺ,
n1, n2, n3, n4, result);
return 0;
}

Autumn Semester 2019 Programming and Data Structure 13

 Function Not Returning Any Value

• Example: A function which prints if a number if

divisible by 7 or not.

void div7 (int n)

{
if ((n % 7) == 0)
printf (ʺ%d is divisible by 7ʺ, n);
else
printf (ʺ%d is not divisible by 7ʺ, n);

return; OPTIONAL
}

Autumn Semester 2019 Programming and Data Structure 14

• Returning control
– If nothing returned
• return;
• or, until reaches right brace

– If something returned
• return expression;

Autumn Semester 2019 Programming and Data Structure 15

 Function Prototypes

• Usually, a function is defined before it is called.

– main() is the last function in the program.
– Easy for the compiler to identify function definitions in a single
scan through the file.

• However, many programmers prefer a top-down

approach, where the functions follow main().
– Must be some way to tell the compiler.
– Function prototypes are used for this purpose.
• Only needed if function definition comes after use.

Autumn Semester 2019 Programming and Data Structure 16

 – Function prototypes are usually written at the
beginning of a program, ahead of any functions
(including main()).
– Examples:
int gcd (int A, int B);
void div7 (int number);

• Note the semicolon at the end of the line.

• The argument names can be different; but it is a good practice
to use the same names as in the function definition.

Autumn Semester 2019 Programming and Data Structure 17

 Some Points

• A function cannot be defined within another function.

– All function definitions must be disjoint.
• Nested function calls are allowed.
– A calls B, B calls C, C calls D, etc.
– The function called last will be the first to return.
• A function can also call itself, either directly or in a cycle.
– A calls A
– A calls B, B calls C, C calls back A.
– Called recursive call or recursion.

Autumn Semester 2019 Programming and Data Structure 18

 Example:: main calls ncr, ncr calls fact
#include <stdio.h> int ncr (int n, int r)
{
int ncr (int n, int r); return (fact(n) /
int fact (int n); fact(r) / fact(n-r));
}
void main()
{
int i, m, n, sum=0; int fact (int n)
scanf (ʺ%d %dʺ, &m, &n); {
int i, temp=1;
for (i=1; i<=m; i+=2) for (i=1; i<=n; i++)
sum = sum + ncr(n,i); temp *= i;
return (temp);
printf (ʺResult: %d \nʺ, }
sum);
}

Autumn Semester 2019 Programming and Data Structure 19

 #include <stdio.h>
int A;
Variable Scope
void main()
{ A = 1;
myProc();
printf ( "A = %d\n", A);
}
Output:
void myProc()
{ int A = 2;
while (A==2 ) A = 3
{
int A = 3; A = 2
printf ( "A = %d\n", A);
break;
A = 1
}
printf ( "A = %d\n", A);
}
Autumn Semester 2019 Programming and Data Structure 20
 Math Library Functions

• Math library functions

– perform common mathematical calculations
#include <math.h>

• Format for calling functions

FunctionName (argument);
• If multiple arguments, use comma-separated list
printf (ʺ%fʺ, sqrt(900.0));
• Calls function sqrt, which returns the square root of its argument.
• All math functions return data type double.
– Arguments may be constants, variables, or expressions.

Autumn Semester 2019 Programming and Data Structure 21

 Math Library Functions
double acos(double x) – Compute arc cosine of x.
double asin(double x) – Compute arc sine of x.
double atan(double x) – Compute arc tangent of x.
double atan2(double y, double x) – Compute arc tangent of y/x.
double ceil(double x) – Get smallest integral value that exceeds x.
double floor(double x) – Get largest integral value less than x.
double cos(double x) – Compute cosine of angle in radians.
double cosh(double x) – Compute the hyperbolic cosine of x.
double sin(double x) – Compute sine of angle in radians.
double sinh(double x) – Compute the hyperbolic sine of x.
double tan(double x) – Compute tangent of angle in radians.
double tanh(double x) – Compute the hyperbolic tangent of x.
double exp(double x) – Compute exponential of x.
double fabs (double x ) – Compute absolute value of x.
double log(double x) – Compute log to the base e of x.
double log10 (double x ) – Compute log to the base 10 of x.
double pow (double x, double y) – Compute x raised to the power y.
double sqrt(double x) – Compute the square root of x.
Autumn Semester 2019 Programming and Data Structure 22
 An example
#include <stdio.h>
#include <math.h>
Must be compiled as:
int main()
gcc examp.c -lm
{
double value, result;
float a, b;

value = 2345.6; a = 23.5; Link math library

result = sqrt(value);
b = pow(23.5,4);

printf (ʺ\nresult = %f, b = %fʺ, result, b);

return 0;
}

Autumn Semester 2019 Programming and Data Structure 23

 Header Files

• Header files
– Contain function prototypes for library functions
– <stdlib.h> , <math.h> , etc.
– Load with: #include <filename>
– Example:
#include <math.h>

• Custom header files

– Create file(s) with function definitions.
– Save as filename.h (say).
– Load in other files with #include ʺfilename.hʺ
– Reuse functions.

Autumn Semester 2019 Programming and Data Structure 24

 Calling Functions: Call by Value and Call by
Reference
• Used when invoking functions.
• Call by value
– Copy of argument passed to function.
– Changes in function do not affect original.
– Use when function does not need to modify argument.
• Avoids accidental changes.
• Call by reference.
– Passes the reference to the original argument.
– Execution of the function may affect the original.
– Not directly supported in C – can be effected using pointers.

C supports only “call by value”

Autumn Semester 2019 Programming and Data Structure 25

 Example: Random Number Generation

• rand function
– Prototype defined in <stdlib.h>
– Returns "random" number between 0 and RAND_MAX
i = rand();
– Pseudorandom
• Preset sequence of "random" numbers
• Same sequence for every function call
• Scaling
– To get a random number between 1 and n
1 + (rand() % n)
– To simulate the roll of a dice:
1 + (rand() % 6)

Autumn Semester 2019 Programming and Data Structure 26

 Random Number Generation: Contd.
• srand function
– Prototype defined in <stdlib.h>
– Takes an integer seed, and randomizes the random number
generator.
srand (seed);

Autumn Semester 2019 Programming and Data Structure 27

#include <stdio.h>
#include <stdlib.h>
int main() A programming example.
{ Randomizing die rolling
int i; program.
unsigned seed;
printf (ʺEnter seed: ʺ);
scanf (ʺ%uʺ, &seed);
srand (seed);
for (i = 1; i <= 10; i++) {
printf(ʺ%10d ʺ, 1 + (rand() % 6));
if (i % 5 == 0)
printf (ʺ\nʺ);
}
return 0;
} Autumn Semester 2019 Programming and Data Structure 28
 Program Output

Enter seed: 67
6 1 4 6 2
1 6 1 6 4

Enter seed: 867

2 4 6 1 6
1 1 3 6 2

Enter seed: 67
6 1 4 6 2
1 6 1 6 4
 #define: Macro definition

• Preprocessor directives are handled by the

preprocessor, before the actual compilation
• Preprocessor directive in the following form:
#define string1 string2

– Replaces string1 by string2 wherever it occurs before

compilation.
– For example,
#define PI 3.1415926
#define discr b*b-4*a*c

Autumn Semester 2019 Programming and Data Structure 30

 #define: Macro definition

#include <stdio.h> #include <stdio.h>

#define PI 3.1415926 void main()
void main() {
{ float r=4.0, area;
float r=4.0, area; area = 3.1415926*r*r;
area = PI*r*r; }
}

This replacement is done by the preprocessor

Autumn Semester 2019 Programming and Data Structure 31

 #define with arguments

• #define statement may be used with arguments.

– Example: #define sqr(x) x*x
– How macro substitution will be carried out?
r = sqr(a) + sqr(30); è r = a*a + 30*30;
r = sqr(a+b); è r = a+b*a+b;

WRONG?
– The macro definition should have been written as:
#define sqr(x) (x)*(x)
r = (a+b)*(a+b);

Autumn Semester 2019 Programming and Data Structure 32

 Recursion

• A process by which a function calls itself repeatedly.

– Either directly.
• X calls X.
– Or cyclically in a chain.
• X calls Y, and Y calls X.
• Used for repetitive computations in which each action is
stated in terms of a previous result.
fact(n) = n * fact (n-1)

Autumn Semester 2019 Programming and Data Structure 33

 Contd.

• For a problem to be written in recursive form,

two conditions are to be satisfied:
– It should be possible to express the problem in
recursive form.
– The problem statement must include a stopping
condition
fact(n) = 1, if n = 0
= n * fact(n-1), if n > 0

Autumn Semester 2019 Programming and Data Structure 34

• Examples:
– Factorial:
fact(0) = 1
fact(n) = n * fact(n-1), if n > 0

– GCD:
gcd (m, m) = m
gcd (m, n) = gcd (m%n, n), if m > n
gcd (m, n) = gcd (n, n%m), if m < n

– Fibonacci series (0, 1, 1, 2, 3, 5, 8, 13, ….)

fib (0) = 0
fib (1) = 1
fib (n) = fib (n-1) + fib (n-2), if n > 1

Autumn Semester 2019 Programming and Data Structure 35

 Example 1 :: Factorial

long int fact (n)

int n;
{
if (n == 0)
return (1);
else
return (n * fact(n-1));
}

Autumn Semester 2019 Programming and Data Structure 36

• Mechanism of execution
– When a recursive program is executed, the recursive
function calls are not executed immediately.
• They are kept aside (on a stack) until the stopping condition
is encountered.
• The function calls are then executed in reverse order.

Autumn Semester 2019 Programming and Data Structure 37

 Example :: Calculating fact(4)

– First, the function calls will be processed:

fact(4) = 4 * fact(3)
fact(3) = 3 * fact(2)
fact(2) = 2 * fact(1)
fact(1) = 1 * fact(0)

– The actual values return in the reverse order:

fact(0) = 1
fact(1) = 1 * 1 = 1
fact(2) = 2 * 1 = 2
fact(3) = 3 * 2 = 6
fact(4) = 4 * 6 = 24

Autumn Semester 2019 Programming and Data Structure 38

 Example 2 :: GCD

int gcd (m, n)

int m, n;
{
if(m == n)
return m;
else if(n==0)
return m;
else
return gcd (n, m%n);
}

Autumn Semester 2019 Programming and Data Structure 39

 Example 2 :: GCD
int gcd (m, n)
int m, n;
{
printf( "\n Within gcd(): m = %d, n = %d",
m, n );
if(m == n)
return m;
else if(n==0)
return m;
else
return gcd (n, m%n);
}
int main()
{
int a, b;
scanf(“%d %d”, &a, &b);
printf( "\n a = %d, b = %d, gcd = %d", a, b,
gcd(a,b) );
}
Autumn Semester 2019 Programming and Data Structure 40
 Example 2: GCD

Inputs: 100, 30 Inputs: 100, 29

Within gcd(): m = 100, n = 30 Within gcd(): m = 100, n = 29

Within gcd(): m = 30, n = 10 Within gcd(): m = 29, n = 13
Within gcd(): m = 10, n = 0 Within gcd(): m = 13, n = 3
a = 100, b = 30, gcd = 10 Within gcd(): m = 3, n = 1
Within gcd(): m = 1, n = 0
Inputs: 30, 100 a = 100, b = 29, gcd = 1

Within gcd(): m = 30, n = 100

Within gcd(): m = 100, n = 30
Within gcd(): m = 30, n = 10
Within gcd(): m = 10, n = 0
a = 30, b = 100, gcd = 10

Autumn Semester 2019 Programming and Data Structure 41

 Example 3 :: Fibonacci number

• Fibonacci number f(n) can be defined as:

f(0) = 0
f(1) = 1
f(n) = f(n-1) + f(n-2), if n > 1
– The successive Fibonacci numbers are:
0, 1, 1, 2, 3, 5, 8, 13, 21, …..

• Function definition:
int f (int n)
{
if (n < 2) return (n);
else return (f(n-1) + f(n-2));
}

Autumn Semester 2019 Programming and Data Structure 42

 Tracing Execution

• How many times the f(4)

function is called when
evaluating f(4) ? f(3) f(2)

f(2) f(1) f(1) f(0)

• Inefficiency: f(1) f(0)

– Same thing is computed

several times. called 9 times

Autumn Semester 2019 Programming and Data Structure 43

 Performance Tip

• Avoid Fibonacci-style recursive programs which

result in an exponential “explosion” of calls.
• Avoid using recursion in performance situations.
• Recursive calls take time and consume additional
memory.

Autumn Semester 2019 Programming and Data Structure 44

 Example 4 :: Towers of Hanoi Problem

1
2
3
4
5

LEFT CENTER RIGHT

Autumn Semester 2019 Programming and Data Structure 45

• The problem statement:
– Initially all the disks are stacked on the LEFT pole.
– Required to transfer all the disks to the RIGHT pole.
• Only one disk can be moved at a time.
• A larger disk cannot be placed on a smaller disk.
– CENTER pole is used for temporary storage of disks.

Autumn Semester 2019 Programming and Data Structure 46

• Recursive statement of the general problem of n
disks.
– Step 1:
• Move the top (n-1) disks from LEFT to CENTER.
– Step 2:
• Move the largest disk from LEFT to RIGHT.
– Step 3:
• Move the (n-1) disks from CENTER to RIGHT.

Autumn Semester 2019 Programming and Data Structure 47

#include <stdio.h>

void transfer (int n, char from, char to, char temp);

main()
{
int n; /* Number of disks */
scanf (ʺ%dʺ, &n);
transfer (n, ’L’, ’R’, ’C’);
}

void transfer (int n, char from, char to, char temp)

{
if (n > 0) {
transfer (n-1, from, temp, to);
printf (ʺMove disk %d from %c to %c \nʺ, n, from, to);
transfer (n-1, temp, to, from);
}
return;
}
Autumn Semester 2019 Programming and Data Structure 48
 4
Move disk 1 from L to C
3
Move disk 2 from L to R
Move disk 1 from L to R
Move disk 1 from C to R
Move disk 2 from L to C
Move disk 3 from L to C
Move disk 1 from R to C
Move disk 1 from R to L
Move disk 3 from L to R
Move disk 2 from R to C
Move disk 1 from C to L
Move disk 1 from L to C
Move disk 2 from C to R
Move disk 4 from L to R
Move disk 1 from L to R
Move disk 1 from C to R
Move disk 2 from C to L
Move disk 1 from R to L
Move disk 3 from C to R
Move disk 1 from L to C
Move disk 2 from L to R
Move disk 1 from C to R

Autumn Semester 2019 Programming and Data Structure 49

 5 Move disk 5 from L to R
Move disk 1 from L to R Move disk 1 from C to L
Move disk 2 from L to C Move disk 2 from C to R
Move disk 1 from R to C Move disk 1 from L to R
Move disk 3 from L to R Move disk 3 from C to L
Move disk 1 from C to L Move disk 1 from R to C
Move disk 2 from C to R Move disk 2 from R to L
Move disk 1 from L to R Move disk 1 from C to L
Move disk 4 from L to C Move disk 4 from C to R
Move disk 1 from R to C Move disk 1 from L to R
Move disk 2 from R to L Move disk 2 from L to C
Move disk 1 from C to L Move disk 1 from R to C
Move disk 3 from R to C Move disk 3 from L to R
Move disk 1 from L to R Move disk 1 from C to L
Move disk 2 from L to C Move disk 2 from C to R
Move disk 1 from R to C Move disk 1 from L to R

Autumn Semester 2019 Programming and Data Structure 50

 Recursion vs. Iteration

• Repetition
– Iteration: explicit loop
– Recursion: repeated function calls
• Termination
– Iteration: loop condition fails
– Recursion: base case recognized
• Both can have infinite loops
• Balance
– Choice between performance (iteration) and good
software engineering (recursion).

Autumn Semester 2019 Programming and Data Structure 51

 How are function calls implemented?

• The following applies in general, with minor variations

that are implementation dependent.
– The system maintains a stack in memory.
• Stack is a last-in first-out structure.
• Two operations on stack, push and pop.
– Whenever there is a function call, the activation
record gets pushed into the stack.
• Activation record consists of:
– the return address in the calling program,
– the return value from the function, and
– the local variables inside the function.

Autumn Semester 2019 Programming and Data Structure 52

 main()
{ int gcd (int x, int y)
…….. {
x = gcd (a, b); ……..
…….. ……..
} return (result);
}

Local
Activation Variables
record Return Value
Return Addr
STACK

Before call After call After return

Autumn Semester 2019 Programming and Data Structure 53
main()
{
…… int ncr (int n,int r)
x=ncr(a,b); {
…… return (fact(n)/ int fact (int n)
} fact(r)/fact(n-r)); {
3 times
} ………
return(result);
}

3 times

LV2, RV2, RA2

LV1, RV1, RA1 LV1, RV1, RA1 LV1, RV1, RA1

Before call Call ncr Call fact fact returns ncr returns
Autumn Semester 2019 Programming and Data Structure 54
 What happens for recursive calls?
• What we have seen ….
– Activation record gets pushed into the stack when a
function call is made.
– Activation record is popped off the stack when the
function returns.
• In recursion, a function calls itself.
– Several function calls going on, with none of the
function calls returning back.
• Activation records are pushed onto the stack continuously.
• Large stack space required.
• Activation records keep popping off, when the termination
condition of recursion is reached.

Autumn Semester 2019 Programming and Data Structure 55

• We shall illustrate the process by an example of
computing factorial.
– Activation record looks like:

Local
Variables
Return Value
Return Addr

Autumn Semester 2019 Programming and Data Structure 56

 Example:: main() calls fact(3)

main()
{
int n;
n = 3;
printf (”%d \n”, fact(n) );
}

int fact (n)

int n;
{
if (n == 0)
return (1);
else
return (n * fact(n-1));
}

Autumn Semester 2019 Programming and Data Structure 57

 TRACE OF THE STACK DURING EXECUTION

n = 0
1
RA .. fact
n = 1 n = 1 n = 1 fact
main
- - 1*1 = 1 returns
RA .. fact RA .. fact RA .. fact to main
calls fact
n = 2 n = 2 n = 2 n = 2 n = 2
- - - - 2*1 = 2
RA .. fact RA .. fact RA .. fact RA .. fact RA .. fact
n = 3 n = 3 n = 3 n = 3 n = 3 n = 3 n = 3
- - - - - - 3*2 = 6
RA .. main RA .. main RA .. main RA .. main RA .. main RA .. main RA .. main

Autumn Semester 2019 Programming and Data Structure 58

 Do Yourself
• Trace the activation records for the following version of Fibonacci
sequence.
#include <stdio.h>
int f (int n)
{ Local
int a, b; Variables
if (n < 2) return (n); (n, a, b)
else { Return Value
X a = f(n-1); Return Addr
b = f(n-2); (either main,
Y return (a+b); } or X, or Y)
}
main() {
printf(ʺFib(4) is: %d \nʺ, f(4));
} main
Autumn Semester 2019 Programming and Data Structure 59
Storage Class of Variables
 What is Storage Class?

• It refers to the permanence of a variable, and its

scope within a program.
• Four storage class specifications in C:
– Automatic: auto
– External: extern
– Static: static
– Register: register

Autumn Semester 2019 Programming and Data Structure 61

 Automatic Variables

• These are always declared within a function and are

local to the function in which they are declared.
– Scope is confined to that function.
• This is the default storage class specification.
– All variables are considered as auto unless explicitly
specified otherwise.
– The keyword auto is optional.
– An automatic variable does not retain its value once
control is transferred out of its defining function.

Autumn Semester 2019 Programming and Data Structure 62

#include <stdio.h> main()
{
int factorial(int m) auto int n;
{ for (n=1; n<=10; n++)
auto int i; printf (ʺ%d! = %d \nʺ,
auto int temp=1; n, factorial (n));
for (i=1; i<=m; i++) }
temp = temp * i;
return (temp);
}

Autumn Semester 2019 Programming and Data Structure 63

 Static Variables

• Static variables are defined within individual functions and

have the same scope as automatic variables.
• Unlike automatic variables, static variables retain their
values throughout the life of the program.
– If a function is exited and re-entered at a later time, the static
variables defined within that function will retain their previous
values.
– Initial values can be included in the static variable declaration.
• Will be initialized only once.
• An example of using static variable:
– Count number of times a function is called.

Autumn Semester 2019 Programming and Data Structure 64

EXAMPLE 1
#include <stdio.h>

int factorial (int n)

{
static int count=0;
count++;
printf (ʺn=%d, count=%d \nʺ, n, count);
if (n == 0) return 1;
else return (n * factorial(n-1));
}

main()
{
int i=6;
printf (ʺValue is: %d \nʺ, factorial(i));
}

Autumn Semester 2019 Programming and Data Structure 65

• Program output:
n=6, count=1
n=5, count=2
n=4, count=3
n=3, count=4
n=2, count=5
n=1, count=6
n=0, count=7
Value is: 720

Autumn Semester 2019 Programming and Data Structure 66

EXAMPLE 2
#include <stdio.h>

int fib (int n)

{
static int count=0;
count++;
printf (ʺn=%d, count=%d \nʺ, n, count);
if (n < 2) return n;
else return (fib(n-1) + fib(n-2));
}

main()
{
int i=4;
printf (ʺValue is: %d \nʺ, fib(i));
}

Autumn Semester 2019 Programming and Data Structure 67

• Program output: f(4)

n=4, count=1
f(3) f(2)
n=3, count=2
n=2, count=3
n=1, count=4 f(2) f(1) f(1) f(0)
n=0, count=5
n=1, count=6 f(1) f(0)
n=2, count=7
n=1, count=8
n=0, count=9
Value is: 3 [0,1,1,2,3,5,8,….]

Autumn Semester 2019 Programming and Data Structure 68

 Register Variables

• These variables are stored in high-speed

registers within the CPU.
– Commonly used variables may be declared as register
variables.
– Results in increase in execution speed.
– The allocation is done by the compiler.

Autumn Semester 2019 Programming and Data Structure 69

 External Variables

• They are not confined to single functions.

• Their scope extends from the point of definition
through the remainder of the program.
– They may span more than one functions.
– Also called global variables.
• Alternate way of declaring global variables.
– Declare them outside the function, at the beginning.

Autumn Semester 2019 Programming and Data Structure 70

 #include <stdio.h>

int count=0; /** GLOBAL VARIABLE **/

int factorial (int n)
{
count++;
printf (ʺn=%d, count=%d \nʺ, n, count);
if (n == 0) return 1;
else return (n * factorial(n-1));
}

main() {
int i=6;
printf (ʺValue is: %d \nʺ, factorial(i));
printf (ʺCount is: %d \nʺ, count);
}

Autumn Semester 2019 Programming and Data Structure 71