Programming for Problem Solving – I

Lecture - 7
Prof. Sankhadeep Chatterjee
Department of Computer Science & Engineering, UEMK
 Lecture - 7

Functions
 References
• Byron Gottfried, Schaum's Outline of Programming with C,
McGraw-Hill (Chapter 7)
• Brian W. Kernighan and Dennis M. Ritchie, The C Programming
Language, Pearson
• C How to Program, 8th Ed. Deitel & Deitel, Pearson
• C Learning And Building Business And System Applications,
S.K. Rout, 2nd Ed. Prentice Hall of India
• Computer Fundamentals & C Programming, Sumitabha Das,
McGraw-Hill
• Programming in ANSI C, E. Balagurusamy, McGraw-Hill
 Function
• A program segment that carries out some
specific, well-defined task

• Example
– A function to add two numbers
– A function to find the largest of n numbers

• A function will carry out its intended task

whenever it is called or invoked
 Function contd.
• 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

• Functions call other functions as instructions

 Function Control Flow

main()
void print_msg()
{ {
print_msg(); printf(“Hello”);
}
}
 Functions contd.
• Calling function (caller) may pass information
to the called function (callee) as
parameters/arguments
– For example, the numbers to add
• The callee may return a single value to the
caller
– Some functions may not return anything
 Function: Example
Calling Function (Caller) Called Function (Callee)

int main() int add(int x, int y)

{ {
int a, b, sum; int z;
scanf(“%d%d”,&a,&b); z = x + y;
sum = add(a, b); return z;
printf(“Sum is %d”, sum); }
}

Calling / Invoking Actual Parameters / Formal Parameters /

‘add’ Function Arguments Arguments
 Why Functions?
• Allows one to develop a program in a modular
fashion
– Divide-and-conquer approach
– Construct a program from small pieces or
components
• Use existing functions as building blocks for
new programs
 Defining a Function
• A function definition has two parts:
– The first line, called header
– The body of the function

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

{
declarations and statements
}
 Function: Example
Return Type Formal Parameters /
Arguments

int add(int x, int y)

{
int z;
z = x + y; Body
return z;
}
Returned Value
 return statement
• In a value-returning function, return does two
distinct things
– specify the value returned by the execution of the
function
– terminate that execution of the callee and transfer
control back to the caller
 Function: Example

int main() int add(int x, int y)

{ {
int sum; int z;
sum = add(2, 3); z = x + y;
printf(“Sum is %d”, sum); return z;
} }
 return statement
• A function can only return one value
– The value can be any expression matching the
return type
– but it might contain more than one return
statement.
• In a void function
– return is optional at the end of the function body.
– return may also be used to terminate execution
of the function explicitly.
– No return value should appear following return.
 Function Prototypes
• Usually, a function is #include<stdio.h>
void even_odd(int num)
defined before it is
{
called if(num % 2 == 0)
– main() is the last printf(“Even Number”);
function in the else
program written printf(“Odd Number”);
}
– Easy for the compiler
to identify function main()
definitions in a single {
scan through the file int x;
scanf(“%d”,&x);
even_odd(x);
}
 Function Prototypes
#include<stdio.h>
• However, many void even_odd(int);
programmers prefer a main()
top-down approach, {
where the functions are int x;
written after main() scanf(“%d”,&x);
– Must be some way to even_odd(x);
tell the compiler }
– Function prototypes void even_odd(int num)
are used for this {
purpose if(num % 2 == 0)
• Only needed if printf(“Even Number”);
function definition else
comes after use printf(“Odd Number”);
}
 Function Prototypes
• Function prototypes are usually written at
the beginning of a program, ahead of any
functions (including main())
• Prototypes can specify parameter names
or just types (more common)
• Examples:
– int add (int , int );
• Note the semicolon at the end of the line.
 Output ?
main() void fun()
{ {
int a; int a;
a = 2; a = 5;
fun(); }
printf(“%d”,a);
}
Local Variable.
No longer exists after function returns
 Scope of Variables
• Part of the program from which the value of the
variable can be used (seen)
• Scope of a variable - Within the block in which the
variable is defined
– Block = group of statements enclosed within { }
• Local variable – scope is usually the function in
which it is defined
– So two local variables of two functions can have
the same name, but they are different variables
• Global variables – declared outside all functions
(even main)
– scope is entire program by default, but can be
hidden in a block if local variable of same name
defined
 Scope of Variables
int a = 1; Global Variable.
void fun()
{
int a;
Local Variable.
a = 2;
printf(“%d”,a); Output: 2
}

main()
{
fun();
printf(“%d”,a); Output: 1
}
 Recursive Functions
• A function can also call itself, either directly or in
a cycle
– A calls B, B calls C, C calls back A.
• Factorial of a number
f(n) = n * f(n-1), n>0
= 0, n = 0
• Fibonacci Series
f(n) = f(n-1) + f(n-2), n>2
= 1, n = 2
= 0, n = 1
Thank You