Functions

• A function is a sub program, which performs a

particular task when called.
• A C program is a collection of some functions.
• main() is the predefined function from where the
execution of a program starts.
• C program = Main() + user defined functions
 ..continued
• Uses of functions:
• Re-useability
• Modularity
• Re-usability: C functions are used to avoid rewriting same code again and
again in a program.
• We can call functions any number of times in a program and from any place in
a program for the same task to be performed.
• Modularity: Dividing a big task into small pieces improves understandability
of very large C programs.
• A large C program can easily be tracked when it is divided into functions.
 Defining a Function
• Syntax:
function definition function
declaration

return_type function_name(List of
parameters)
{
//set of statements
function body
 ..continued
• Function definition – This contains all the
statements to be executed.
Function definition = function declaration +function body
A function body is a group of statements enclosed
in flower brackets.
eg: void main() function declaration
{
int a=10; function definition
function body
printf(“a = %d”,a);
}
 Function terminology
• Function prototype
• Function definition
• Function call

Function prototype or declaration - This informs

compiler about the function name, function
parameters and return value’s data type.
Syntax: return_type function_name(parameter list);
This is written before main() function. To inform the
compiler that there exists a function in the program.
 Function Call
• This statement actually calls the function.
• Syntax: function_name( list of parameter
values);
• This statement is written in the calling
function.
• With this statement, the control is
transferred to the function definition.
• Eg: sum(10,20);
 Function calls
• Functions can be defined in any one of the
following 4 different ways.
 No arguments , No return value .
 No arguments , With return value .
 With arguments , No return value .
 With arguments , With return value .
• Arguments:-
These values are passed from main()
function to the invoked function . Generally
Ex:- Program to print the sum of given two numbers using
functions?
i)No arguments , No return value

void add ( ) ; //function

prototype
void main()
{
add(); //function calling
}
void add() //function definition
{
int a,b,c;
 ii)No arguments , With return value

int add ( ) ; //function prototype

void main()
{
printf(“\nsum is=%d”,add()); //
function call
}
int add() ; //function definition
{
int a,b,c;
 iii)With arguments , No return value

void add ( int , int ) ; //function

prototype
void main()
{
int a , b ;
printf(“enter any two numbers”);
scanf(“%d%d”,&a,&b);
add(a,b); //function call
}
iv)With arguments , With return value

int add ( int , int ) ; //function

prototype
void main()
{
int a , b ;
printf(“enter any two numbers”);
scanf(“%d%d”,&a,&b);
printf(“sum is=%d”,add(a,b));
//function call
 Methods of Function calls

There are two methods

that a C function can
be called from a
program. They are,

Call by value Call by reference

 Arguments
• Actual Argument: This is the argument
which is used in the function call.
– Eg: sum(a,b); // a and b are actual arguments
• Formal Argument: This is the argument
which is used in the function definition.
– Eg: void sum(int m, int n) //m and n are
formal arguments.
{
.
.
}
 Call/pass by value
• In this method, the values only values of
actual arguments are passed into formal
arguments.
• Different Memory is allocated for both
actual and formal parameters.
• The value of the actual parameter can not
be modified by formal parameter.
 Call/pass by reference

– In this method, the address of the variable, not value ,is

passed to the function as parameter.
– Same memory is used for both actual and formal
parameters since only address is used by both
parameters.
– The value of the actual parameter can be modified by
formal parameter.
 Recursion
• It is possible in c for functions to call
themselves.
• Recursion is a technique in which a
function calls itself.
• Eg: int fact(int a) //function definition
{
int f;
if(a==1)
return 1;
else
f=a*fact(a-1); //function call
 Scope of the variable
• Two kinds of variables: Local and Global
– Local - A variable declared within the function
is called as local variable. This can be used
within that function only.
• Eg: void main()
{
int x,y;
.
.
}
X and y are local variables. Their scope is upto main function.
They can be used in only main function.
 Scope of the variables
• Global variable: A variable declared global
section of the program. This can be used
anywhere in the program.
• Eg: int x; // global variable
void main()
{
int y; // local variable
.
}
void sum()
{
int a,b,c; //local variables
.
 C – Storage Class Specifiers

• Storage class specifiers tells the compiler

– where to store a variable,
– how to store the variable,
– what is the initial value of the variable and
– life time of the variable.
• Syntax: storage_specifier data_type
variable _name
• Types : 4
– auto
– extern
 auto
• The scope of this auto variable is within
the function only.

• It is declared using auto keyword. It is

equivalent to local variable.

• All local variables are auto variables by

default.
 extern
• The scope of the extern variable is global.

• It is available throughout the main

program.

• Is declared using the keyword extern. Can

be declared anywhere in the program.

• It is stored in memory.
 static
• It’s scope is local. It’s value persists
between function calls.

• Declared using static keyword.

• Stored in memory.

• Default is zero.
 register
• Scope is local.

• Available within the function.

• Stored in register memory.

• Default value is garbage value.

• Declared using register keyword.

 …continued
Initial /
S.No Storage Storage Scop
default Life
. Specifier place e
value

CPU Garbage
1 auto local Within the function only.
Memory value

Till the end of the main program. Variable

CPU
2 extern Zero Globaldefinition might be anywhere in the C
memory
program

CPU Retains the value of the variable between

3 static Zero local
memory different function calls.

Register Garbage
4 register local Within the function
memory value
 Structures
• A structure is a collection of one or more
variables, usually of different types,
grouped together under a single name.

• A structure can be declared using the

keyword ‘struct’.

• Syntax: struct structure_name

{
 Structure example
• structure example: struct book
{
char book_name[20];
char author[20];
int no_of_pages;
float price;
}
 Structure members
• Each variable inside the structure
definition is called a structure member.

• In the book example above,

book_name , author, no_of_pages and
price are the struct members.
 Structure variables
• A structure variable can be declared using
the structure name.

• Syntax:
struct struct_name
variable_name1,variable_name2,…;

• Example: struct book b1,b2,b3;

 Accessing structure members
• Structure members can be accessed using
the dot(.) operator.

• Syntax : struct_variable . struct

member;

• Example : b1.book_name;
b2.book_name;
etc.,
 Initializing structure members
• Intializing can be done in two ways:
1. using assignment operator (=)..
2. from the keyboard
1. Using the assignment operator:
eg: b1.no_of_pages=100;
b1. price=235;

2. From the keyboard:

eg: scanf(“%d”,&b1.no_of_pages);
 Array of structures
• An array of structures can be declared in
the same way we declare any other array.

• Example: struct book b1[10];

b1 is the array of structures which
holds 10 structures.
• Each structure variable is accessed
using the array index.
 Union
• A Union is a collection of one or more
variables, usually of different types,
grouped together under a single name.

• A union can be declared using the

keyword ‘union’.

• Syntax: union union_name

{
 union example
• Union example: union book
{
char book_name[20];
char author[20];
int no_of_pages;
float price;
}
 Union members
• Each variable inside the union definition is
called a union member.

• In the book example above,

book_name , author, no_of_pages and
price are the union members.
 union variables
• A union variable can be declared using the
union name.

• Syntax:
union union_name
variable_name1,variable_name2,…;

• Example: union book b1,b2,b3;

 Accessing union members
• union members can be accessed using
the dot(.) operator.

• Syntax : union_variable .union

member;

• Example : b1.book_name;
b2.book_name;
etc.,
 Initializing union members
• Intializing can be done in two ways:
1. using assignment operator (=)..
2. from the keyboard
1. Using the assignment operator:
eg: b1.no_of_pages=100;
b1. price=235;

2. From the keyboard:

eg: scanf(“%d”,&b1.no_of_pages);
 Array of unions
• An array of unions can be declared in the
same way we declare any other array.

• Example: union book b1[10];

b1 is the array of unions which
holds 10 unions.
• Each union variable is accessed using
the array index.
 Differences between structure and
union
S.no C Structure C Union
Union allocates one common storage space for all its
members.
1 Structure allocates storage space for all its members separately.
Union finds that which of its member needs high storage
space over other members and allocates that much space

2 Structure occupies higher memory space. Union occupies lower memory space over structure.

3 We can access all members of structure at a time. We can access only one member of union at a time.

Structure example: Union example:

struct student union student
{ {
4 int mark; int mark;
char name[6]; char name[6];
double average; double average;
}; };

For above structure, memory allocation will be like

below. For above union, only 8 bytes of memory will be allocated
int mark – 2B since double data type will occupy maximum space of
5
char name[6] – 6B memory over other data types.
double average – 8B Total memory allocation = 8 Bytes
Total memory allocation = 2+6+8 = 16 Bytes
 Pointers
• A pointer is a variable which points to
another variable.

• A pointer stores the address of another

variable.

• Pointers are used to allocate memory

dynamically.
 Address of operator
• & is called as ‘addressof ‘operator.

• Helps to store the address of a variable in

a pointer.

• Then the pointer points to that variable.

• A pointer variable is default initalized to

null.
Advantages of pointers

• To return more than one value from a

function.
• To pass arguments to functions by
reference.
• Pointer concepts are very useful in
development of system software.
• With the address known, data can be
accesses from any where in the
program.