Modularizing and Reusing of code through Functions
Calculation of area of Circle is separated into a separate module from Calculation of area of Ring and the same module can be reused for multiple times.
/* program to find area of a ring */ #include<stdio.h> Repeated & Reusable int main() blocks of code { float a1,a2,a,r1,r2; printf("Enter the radius : "); scanf("%f",&r1); a1 = 3.14*r1*r1; printf("Enter the radius : "); scanf("%f",&r2); a2 = 3.14*r2*r2; a = a1- a2; printf("Area of Ring : %.3f\n", a); }
/* program to find area of a ring */ #include<stdio.h> float area(); Function Declaration int main() { float a1,a2,a; a1 = area(); Function Calls a2 = area(); a = a1- a2; printf("Area of Ring : %.3f\n", a); } float area() Function Definition { float r; printf("Enter the radius : "); scanf("%f", &r); return (3.14*r*r); }
A Function is an independent, reusable module of statements, that specified by a name. This module (sub program) can be called by its name to do a specific task. We can call the function, for any number of times and from anywhere in the program. The purpose of a function is to receive zero or more pieces of data, operate on them, and return at most one piece of data. A Called Function receives control from a Calling Function. When the called function completes its task, it returns control to the calling function. It may or may not return a value to the caller. The function main() is called by the operating system; main() calls other functions. When main() is complete, control returns to the operating system. value of p is copied to loan value of n is copied to terms value of r is copied to iRate float calcInterest(float loan , int terms , float iRate ) { The block is float interest; executed interest = ( loan * terms * iRate )/100; return ( interest ); }
int main() { int n; float p, r, si; printf(Enter Details of Loan1:); scanf( %f %d %f, &p, &n, &r); si =calcInterest( p, n , r ); printf(Interest : Rs. %f, si); printf(Enter Details of Loan2:); }
Called Function
value of interest is assigned to si
Calling Function
Process of Execution for a Function Call
int main() { int n1, n2; printf("Enter a number : "); scanf("%d",&n1); printOctal(n1); readPrintHexa(); printf("Enter a number : "); scanf("%d",&n2); printOctal(n2); printf(\n); }
1 3 7
void printOctal(int n) { printf("Number in octal form : %o \n", n); } void readPrintHexa() { int num; printf("Enter a number : "); scanf("%d",&num); printHexa(num); printf(\n); 4 }
Flow of Control in Multi-Function Program
void printHexa(int n) { printf("Number in Hexa-Decimal form : %x \n",n); }
/* Program demonstrates function calls */ #include<stdio.h> int add ( int n1, int n2 ) ; int main(void) { int a, b, sum; printf(Enter two integers : ); scanf(%d %d, &a, &b); sum = add ( a , b ) ; printf(%d + %d = %d\n, a, b, sum); return 0; }
Function-Its Terminology
Function Name
Declaration (proto type) of Function
Formal Parameters Function Call Actual Arguments
Return Type
/* adds two numbers and return the sum */ int { add ( int x , int y int s; s = x + y; return ( s ); } ) Definition of Function
Parameter List used in the Function
Return statement of the Function Return Value
Categories of Functions
/* using different functions */ int main() { float radius, area; printMyLine(); printf(\n\tUsage of functions\n); printYourLine(-,35); radius = readRadius(); area = calcArea ( radius ); printf(Area of Circle = %f, area); }
void printMyLine() Function with No parameters { and No return value int i; for(i=1; i<=35;i++) printf(%c, -); printf(\n); } void printYourLine(char ch, int n) { Function with parameters and No return value int i; for(i=1; i<=n ;i++) printf(%c, ch); printf(\n); }
float readRadius() Function with return { value & No parameters float r; printf(Enter the radius : ); scanf(%f, &r); return ( r ); }
float calcArea(float r) { Function with return float a; value and parameters a = 3.14 * r * r ; return ( a ) ; }
Note: void means Containing nothing
#include<stdio.h> float length, breadth; int main() { printf("Enter length, breadth : "); scanf("%f %f",&length,&breadth); area(); perimeter(); printf(\nEnter length, breadth: "); scanf("%f %f",&length,&breadth); area(); perimeter(); } External Global Variables Scope: Visible across multiple functions Lifetime: exists till the end of the program. Enter length, breadth : 6 4 Area of Rectangle 1 : 24.00 Perimeter of Rectangle 1 : 20.00 Enter length, breadth : 8 5 Area of Rectangle 2 : 40.00 Perimeter of Rectangle 1 : 26.00
void area() { static int num = 0;
float a; num++; a = (length * breadth); printf(\nArea of Rectangle %d : %.2f", num, a); } void perimeter() { int no = 0; float p; no++; p = 2 *(length + breadth); printf(Perimeter of Rectangle %d: %.2f",no,p); }
Static Local Variables Visible with in the function, created only once when function is called at first time and exists between function calls.
Automatic Local Variables Scope : visible with in the function. Lifetime: re-created for every function call and destroyed automatically when function is exited.
Storage Classes Scope & Lifetime
#include<stdio.h> float length, breadth;
File1.c
File2.c
extern float length, breadth ; /* extern base , height ; --- error */ float rectanglePerimeter() { float p; p = 2 *(length + breadth); return ( p ); }
static float base, height; int main() { float peri; printf("Enter length, breadth : "); scanf("%f %f",&length,&breadth); rectangleArea(); peri = rectanglePerimeter(); printf(Perimeter of Rectangle : %f, peri); printf(\nEnter base , height: "); scanf("%f %f",&base,&height); triangleArea(); } void rectangleArea() { float a; a = length * breadth; printf(\nArea of Rectangle : %.2f", a); } void triangleArea() { float a; a = 0.5 * base * height ; printf(\nArea of Triangle : %.2f", a); }
External Global Variables Scope: Visible to all functions across all files in the project. Lifetime: exists till the end of the program.
Static Global Variables Scope: Visible to all functions with in the file only. Lifetime: exists till the end of the program.
Storage Classes Scope & Lifetime
#include<stdio.h> void showSquares(int n) { if(n == 0) return; else showSquares(n-1); printf(%d , (n*n)); } int main() { showSquares(5); }
Output : 1 4 9 16 25 addition of function calls to callstack showSquares(1) showSquares(2) showSquares(3) showSquares(4) showSquares(5) main()
Preprocessor Directives
A function
calling itself is Recursion
#define #undef #ifdef #ifndef
execution of function calls in reverse
- Define a macro substitution - Undefines a macro - Test for a macro definition - Tests whether a macro is not defined #include - Specifies the files to be included #if - Test a compile-time condition #else - Specifies alternatives when #if test fails #elif - Provides alternative test facility #endif - Specifies the end of #if #pragma - Specifies certain instructions #error - Stops compilation when an error occurs # - Stringizing operator ## - Token-pasting operator
Preprocessor is a program that processes the source code before it passes through the compiler.
call-stack
For More Materials, Text Books, Previous Papers & Mobile updates of [Link], [Link], MBA, MCA of JNTU-HYD,JNTUKAKINADA & JNTU-ANANTAPUR visit [Link]