The arguments that are passed in a function call are called actual arguments. These arguments are defined in the calling function.

The formal arguments are the parameters/arguments in a function declaration. The scope of formal arguments is local to the function definition in which they are used. Formal arguments belong to the called function. Formal arguments are a copy of the actual arguments. A change in formal arguments would not be reflected in the actual arguments.

/* Demonstrating the actual and formal arguments */

#include <stdio.h>
int add(int, int); /* Function Prototype */
int main()
{
  int a = 10, b= 20, sum;

  /* a and b are actual arguments. They are the source
     of data. Caller program supplies the data to called
     function in form of actual arguments. */

  sum = add(a,b); /* function call */

  printf("Sum of %d and %d is: %d \n", a, b, sum);
}

/* a and b are formal parameters. They receive the values from
   actual arguments when this function is called. */

int add(int a, int b)
{
  return  a + b;
}

OUTPUT:

Sum of 10 and 20 is: 30

Functions are called by their names. If the function is without argument, it can be called directly using its name. But for functions with arguments, we have two ways to call them,

1. Call by Value
2. Call by Reference

1. Call by Value: 
In this calling technique we pass the values of arguments which are stored or copied into the formal parameters of functions. Hence, the original values are unchanged only the parameters inside function changes.

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

void swap(int, int);
int main()
{
 int x = 10, y=20;
printf("\n Before swapping the X=%d, Y=%d",x,y);
swap(x,y);
printf("\n After swapping the X=%d, Y=%d",x,y);
}

void swap(int x, int y)
{
int temp;
temp=x;
x=y;
y=temp;
}

In this case if we made any changes with receiving arguments, Those changes are not reflect on outside of the function


2. Call by Reference (or) Call by address:

In this we pass the address of the variable as arguments. In this case the formal parameter can be taken as a reference or a pointer, in both the case they will change the values of the original variable.

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

void swap(int *, int *);
int main()
{
 int x = 10, y=20;
printf("\n Before swapping the X=%d, Y=%d",x,y);
swap(&x, &y);
printf("\n After swapping the X=%d, Y=%d",x,y);
}

void swap(int *x, int *y)
{
int temp;
temp= *x;
*x = *y;
*y = temp;
}

In this case if we made any changes with receiving arguments, Those changes are reflect on outside of the function

                     A function may or may not return a value. A return statement returns a value to the calling function and assigns to the variable in the left side of the calling function. If a function does not return a value, the return type in the function definition and declaration is specified as void.

Syntax:
1. return expression ; (or)
2. return ;


Example:
#include<stdio.h>
#include<conio.h>
int mul(int, int);
main()
{
int a=10,b=20,m;
clrscr();
m=mul(a,b);
printf(“\n Multiplication = %d”,m);
}
int mul(int x,int y)
{
return x*y;
}

A single array (or) entire array can be passed to a function. Both one dimensional array (or) two dimensional (or) multidimensional array can be passed to a function as argument.

1. Passing entire array to function : To pass an entire array to a function, The array name must appear by itself without braces (or) subscripts as an actual arguments with in the function call. whereas formal parameters should be represented as a array variables. In function prototype, array arguments are represented as empty pair of braces.
syntax: function_prototype(data_type []);
calling function(arrayname);
called_function(data_type arrayname[])

Example program for passing entire array to function:
void action(int []);
main()
{
int i, a[10];
clrscr();
printf("\n Enter 5 array elements");
for(i=0;i<5;i++)
scanf("%d",&a[i]);
action(a);
getch();
}
void action(int a[])
{
int i;
for(i=0;i<5;i++)
printf("%d",a[i]);
}


2. Passing single array element to a function: In C-language the name of the array represents the address of its first element. By passing the array name, actually we are passing the address of the array to the called function.

syntax: function_prototype(data_type);
calling function(arrayname[]);
called_function(data_type arrayname)

Example program for passing single array element to a function:
void action(int);
main()
{
int i, a[5];
clrscr();
printf("\n Enter 5 array elements");
for(i=0;i<5;i++)
scanf("%d",&a[i]);
action(a[2]);
getch();
}
void action(int a)
{
printf("%d",a);
}

• The keywords which are used to modify the properties of a variable are called type qualifiers.

Types of C type qualifiers:
There are two types of qualifiers available in C language. They are,
1. const
2. volatile

1. const keyword:

•  Constants are also like normal variables. But, only difference is, their values can’t be modified by the program once they are defined.
•  They refer to fixed values. They are also called as literals.
•  They may be belonging to any of the data type.

• Syntax:       const data_type variable_name;

1. Example program using const keyword in C:
#include <stdio.h>
void main()
{
const int height = 100;  
const float number = 3.14;
printf(“value of height :%d \n”, height );
printf(“value of number : %f \n”, number );

}

2. volatile keyword:
• When a variable is defined as volatile, the program may not change the value of the variable explicitly.
• But, these variable values might keep on changing without any explicit assignment by the program. These types of qualifiers are called volatile.
• For example, if global variable’s address is passed to clock routine of the operating system to store the system time, the value in this address keep on changing without any assignment by the program. These variables are named as volatile variable.

• Syntax:      
volatile data_type variable_name; (or) volatile data_type *variable_name;

1. Example program using const keyword in C:

#include <stdio.h>
void main()
{
const int height = 100;  
const float number = 3.14;
printf(“value of height :%d \n”, height );
printf(“value of number : %f \n”, number );
}

A function calls itself is called recursion and the function is called as recursive function.  The main advantage of recursion is to avoid the length of the code.

Ex: main()
{
     --
     main();
     --
}

Recursion can be classified into two types as:
1. Direct recursion
2. Indirect recursion

1. Direct recursion: A function calls itself is known as direct recursion.

Ex: void sum()
{
--
sum();
--
}

2. Indirect recursion: A function calls another function, which initiates to call of the initial function is known as indirect recursion.

Ex: void sum()
{
call();
}

void call()
{
sum();
}

/*  Example program for GCD using recursion */

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

int rgcd(int,int);
main()
{
int m,n;
clrscr();

printf("\n Enter m,n values:\t");
scanf("%d%d",&m,&n);
printf("\n GCD = %d",rgcd(m,n));
getch();
}

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

Recursion Advantages: 

i. It is easily, simple and understandable.
ii. Using recursion we can avoid unnecessary calling of functions.
iii. The recursion is very flexible in data structure
iv. Using recursion, the length of the program can be reduced.

Recursion Disadvantages:

i. It requires extra storage space. The recursive calls and automatic variables are stored on the stack.
ii. For every recursive calls separate memory is allocated to automatic variables with the same name.
iii. If the programmer forgets to specify the exit condition in the recursive function, the  program will execute out of memory.
iv. The recursion function is not efficient in execution speed and time.

Functions can also be placed within another function.  Such representation is known as nested functions.

Syntax: main() Fun1() Fun2()
{ { {
  --   - -    - -
  --   Fun2();    - -
  Fun1();   - - }
  - - }
}

/* EXAMPLE PROGRAM FOR NESTED FUNCTIONS */

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

void fun1();
void fun2();

main()
{
clrscr();
printf("\n main function starts");
fun1();
printf("\n main function ends");
}
void fun1()
{
printf("\n function1 starts");
fun2();
printf("\n  function1 ends");
}
void fun2()
{
printf("\n function2 starts");
printf("\n function2 ends");
}

Depending on whether arguments are passed or not and function returns any value or not, functions are classified into different categories as:

1. Function with arguments (parameters) and with return type
2. Function with arguments (parameters) and without return type
3. Function without arguments (parameters) and without return type
4. Function without arguments (parameters) and with return type


1 with arguments and with return values
int function ( int );         // function declaration
function ( a );                // function call
int function( int a )       // function definition
{
statements;
return a;
}

2 with arguments and without return values
void function ( int );     // function declaration
function( a );                // function call
void function( int a )   // function definition
{
statements;
}

3 without arguments and without return values
void function();             // function declaration
function();                     // function call
void function()              // function definition
{
statements;
}

4 without arguments and with return values
int function ( );             // function declaration
function ( );                  // function call
int function( )               // function definition
{
statements;
 return a;
}

Note:
• If the return data type of a function is “void”, then, it can’t return any values to the calling function.
• If the return data type of the function is other than void such as “int, float, double etc”, then, it can return values to the calling function.

Case1 : Function with arguments and with return type
#include<stdio.h>
#include<conio.h>
int sum(int, int);  
void main()
{
 int i=10,j=20,k;
 clrscr();
 k=sum(i,j);  
 printf("%d",k);
 getch();
}

int sum(int a, int b)  
{
return a+b;
}


Case2: Function with arguments and without return type
#include<stdio.h>
#include<conio.h>
void sum(int, int);  

void main()
{
 int i=10,j=20;
 clrscr();
 sum(i,j);    
 getch();
}
void sum(int a,int b)  
{
 printf("\n Sum=%d", a+b);
}

Case3 : Function without arguments and with return type
#include<stdio.h>
#include<conio.h>
int sum();

void main()
{
 int k;
 clrscr();
 k=sum();    
 getch();
}
int sum()  
{
 int a=10,b=20;
 return a+b;
}

Case4: Function without arguments and without return type
#include<stdio.h>
#include<conio.h>
void sum();  
void main()
{
sum();    
}
void sum()  
{
int a=10,b=20;
printf("sum=%d",a+b);
}

User defined functions in C

• ·         The functions which are defined by the user at the time of writing program.
• ·         Functions are made for code reusability and for saving time and space.
• ·         For creating user defined function user can follow the three things.

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

• arg1, arg2,  --- , argn arguments are known as “formal arguments”.  List of values passed from the function call are temporarily stored in these formal parameters.
• Variables declared in the function definitions are called local variables.
• After completing implementation of the function, it should return a value to the calling function with a return statement.
• The syntax of a return statement is:

            ctype.h                        -           Character type header file

            math.h             -           Mathematical header file

Functions in c

Benefits of Using User Defined Functions

C – Storage Class Specifiers

Storage class tells the compiler about the following information

Types of Storage Class Specifiers in C:

#include<stdio.h>