Function

A function in C language is a block of code that performs a specific task. It has a name and it is reusable i.e. it can be executed from as many different parts in a C Program as required. It also optionally returns a value to the calling program So function in a C program has some properties discussed below.
Every function has a unique name. This name is used to call function from main()

function. A function can be called from within another function.

A function is independent and it can perform its task without intervention from or

interfering with other parts of the program.

A function performs a specific task. A task is a distinct job that your program must

perform as a part of its overall operation, such as adding two or more integer, sorting an array into numerical order, or calculating a cube root etc.
A function returns a value to the calling program. This is optional and depends upon

the task your function is going to accomplish. Suppose you want to just show few lines through function then it is not necessary to return a value. But if you are calculating area of rectangle and wanted to use result somewhere in program then you have to send back (return) value to the calling function. There are type two of function Built in function User defined function

Built in function C language is collection of various library functions. If you have written a program in C then it is evident that you have used Cs inbuilt functions. Printf, scanf, clrscr etc. all are Cs inbuilt functions. All the predefine functions are define in header files like input/output functions are define in stdio.h file, math functions are define in math.h User Define Function Function which are define by the programmer in the program is called user define functions. These function are declare , define and call by programmer in the program.

Function Declaration (Prototype) and Function Definition in C Programming

Function Declaration Or Prototype Function prototype tells compiler that we are going to use a function which will have given name, return type and parameters. In c language it is necessary to declare a function. Syntax : <return type> FunctionName (Argument1, Argument2, Argument3); Example : int sum(int a int b); or int sum(int, int); Return type must be a valid c data type, function name must be a valid identifier name, arguments must be declare inside function braces arguments name are optional. Function declaration must be terminated by semicolon

Function Definition Function definition is just writing logic of any function. Function definition has two part 1. function header 2. function body . function header is same a function declaration with out the semicolon that specify the returning type, function name, and function arguments. Function body contain the set of statements that are executed when the function is called. For example you have one function prototype in C program for adding two integer numbers (i.e. int add(int, int)) but along with prototype you also have to write logic how that function will behave (respect to above prototype; how you will utilize those two passed integer value and how you will return value) when you will call that function.

Structure of a Function
A general form of a C function looks like this: <return type> FunctionName (Argument1, Argument2, Argument3) { Statement1; Statement2; Statement3; } An example of function. int sum (int x, int y) { int result; result = x + y; return (result); }

Function Prototype and Function Definition Example

#include<stdio.h> #include<conio.h> int add(int, int); void main() { int a,b,c; clrscr();

a=10; b=15; c=add(a,b); printf("\n%d",c); getch(); } int add(int a, int b) { return a+b; }

Advantages of using functions:

There are many advantages in using functions in a program they are: 1. It makes possible top down modular programming. In this style of programming, the high level logic of the overall problem is solved first while the details of each lower level functions is addressed later. 2. The length of the source program can be reduced by using functions at appropriate places. 3. It becomes uncomplicated to locate and separate a faulty function for further study. 4. A function may be used later by many other programs this means that a c programmer can use function written by others, instead of starting over from scratch. 5. A function can be used to keep away from rewriting the same block of codes which we are going use two or more locations in a program. This is especially useful if the code involved is long or complicated.

Function call After declaring and defining a function it can be called form main function or other function. A function can be called more then one time. A function called may pass arguments. It may or may not accept return. Function call must be according to function declaration. Syntax : returntype functionname(list of actual arguments); Example of function calling in C
#include<stdio.h> #include<conio.h> void add(int x,int y) { int result; result = x+y; printf("Sum of %d and %d is %d.\n\n",x,y,result); } void main() { clrscr(); add(10,15); add(55,64); add(168,325); getch(); }

Program Output

Rule for user define functions Function declaration, function definition header must match type, sequence and number of arguments in function call and function definition must match if function is returning a value then function call must be assign to a variable having same type. function declaration can be local or global

Types of functions:
A function may belong to any one of the following categories: 1. Functions with no arguments and no return values. 2. Functions with arguments and no return values. 3. Functions with arguments and return values. 4. Functions that return multiple values. 5. Functions with no arguments and return values.

1. Functions with no arguments and no return value.

A C function without any arguments means you cannot pass data (values like int, char etc) to the called function. Similarly, function with no return type does not pass back data to the calling function. It is one of the simplest types of function in C. This type of function which does not return any value cannot be used in an expression it can be used only as independent statement. Lets have an example to illustrate this. 1. #include<stdio.h> 2. #include<conio.h> 3. void sum(void); 4. void main() 5. { 6. sum (); 7. getch(); 8. } 9. 10. 11. 12. 13. 14. 15. void sum() { int x,y,z; z=x+y; printf(sum=%d,z); }

2. Functions with arguments and no return value.

A C function with arguments can perform much better than function without arguments and no return function type. This type of function can accept data from calling function. In other words, you send data to the called function from calling function but you cannot send result data back to the calling function. Rather, it displays the result on the terminal. But we can control the output of function by providing various values as arguments. Lets have an example to get it better. 1. #include<stdio.h> 2. #include<conio.h> 3. void sum(int x,nt y); 4. void main() 5. { 6. clrscr(); 7. add(30,15); 8. add(63,49); 9. add(952,321); 10. 11. 12. 13. 14. 15. 16. 17. 18. getch(); } void sum(int x, int y) { int result; result = x+y; printf("Sum of %d and %d is %d.\n\n",x,y,result); }

3. Functions with arguments and return value.

This type of function can send arguments (data) from the calling function to the called function and wait for the result to be returned back from the called function back to the calling function. And this type of function is mostly used in programming world because it can do two way communications; it can accept data as arguments as well as can send back data as return value. The data returned by the function can be used later in our program for further calculations. 1. #include<stdio.h> 2. #include<conio.h> 3. int sum(int x, int y); 4. void main()

5. { 6. int z; 7. clrscr(); 8. z = add(952,321); 9. printf("Result %d.\n\n",add(30,55)); 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. printf("Result %d.\n\n",z); getch(); } int add(int x, int y) { int result; result = x+y; return(result); }

4. Functions with no arguments but returns value.

We may need a function which does not take any argument but only returns values to the calling function then this type of function is useful. The best example of this type of function is getchar() library function which is declared in the header file stdio.h. We can declare a similar library function of own. Take a look.

Functions with no arguments and return values.

#include<stdio.h> #include<conio.h> int sum(); void main() { int z; clrscr(); z = add(); printf("Result %d.\n\n",z); getch(); } int add( ) { int result;

result = x+y; return(result); }

5. Functions that return multiple values.

So far, we have learned and seen that in a function, return statement was able to return only single value. That is because; a return statement can return only one value. But if we want to send back more than one value then how we could do this? We have used arguments to send values to the called function, in the same way we can also use arguments to send back information to the calling function. The arguments that are used to send back data are called Output Parameters. It is a bit difficult for novice because this type of function uses pointer. Lets see an example: 1. #include<stdio.h> 2. #include<conio.h>

3. void calc(int x, int y,int *p,int *q);

4. void main() 5. { 6. int a=20, b=11, p,q; 7. clrscr(); 8. calc(a,b,&p,&q); 9. printf(after the function call );

10.
11. 12. 13. 14. 15. 16. 17.

printf(a=%d b=%b,a,b); printf("Sum = %d, Sub = %d",p,q); getch(); } void calc(int x,int y, int *p, int *q) { p=x*y; q=x*y; printf(%d%d,x,y); }

18.
19.

Call by Value and Call by Reference

#include "stdio.h" #include "conio.h" void callByValue(int, int); void callByReference(int *, int *);

int main() { int x=10, y=20; clrscr(); printf("Value of x = %d and y = %d.\n", x,y); callByValue(x, y); printf("\nCall By Value function call...\n"); printf("Value of x = %d and y = %d.\n", x,y); callByReference(&x, &y); printf("\nCall By Reference function call...\n"); printf("Value of x = %d and y = %d.\n", x,y); getch(); return 0; } void callByValue(int x, int y) { int temp; temp = x; x = y; y = temp; } void callByReference(int *x, int *y) { int temp; temp = *x; *x = *y; *y = temp; }

In above call by value and call by reference C program example we have two functions; callByValue() and callByReference() to demonstrate respective logic. Lets start with callByValue() function, this function does swapping of variable using temp variable, we have to pass two integer type data as arguments to this function. The callByReference() function also does swapping of variable using temp variable, but we have to pass two integer type pointeras arguments of this function. To reduce confusion; I kept variable name and logic same in both function except some extra asterisk (*) in callByReference() function. We have declared two integer variable . We will pass those two variables to both function and will try to swap value stored in that. First we are calling function callByValue() and we are passing those two integer value. In line no. 15 we are displaying the value of variables (x and

y) after swapping. I know that swapping didnt happen when we called callByValue() function. In we are calling function callByReference () and here we are passing address ofthose two integer variable. In l we are displaying the value of variables (x and y). As you can see value of variables (x and y) is successfully swapped. You must be thinking why this swapping logic worked for callByReference() function but not for callByValue() function.

Why swapping logic didnt work for Call by Value?

When we called function callByValue() in that time we passed value of x and y, which means we passed copy of x and y variable value not the actual x and y. Now you understood why this method of calling function is called Call by value? Let me tell you one interesting point about this function, when you will print value of x and y variable inside this function it will show you the swapped value. But as I told you this logic works on copy of value so those changes will not reflect in main() function. See below example and output. But in case of callByReference() function we passed address of x and y variables (see line no. 17 carefully there we are passing ampersand & along with variable name), which means actual location of x and y variables. So in this function we swapped value which was stored in x and y location rather than copy of value. As this logic works on address (reference) of variable so this logic is known as Call by Reference. #include "stdio.h" #include "conio.h"
void callByValue(int, int); void callByReference(int *, int *); int main() { int x=10, y=20; clrscr(); printf("Value of x = %d and y = %d.\n", x,y); printf("\nCall By Value function call...\n"); callByValue(x, y); printf("Value of x = %d and y = %d.\n", x,y); printf("\nCall By Reference function call...\n"); callByReference(&x, &y); printf("Value of x = %d and y = %d.\n", x,y); getch(); return 0; } void callByValue(int x, int y) { int temp; temp = x; x = y;

y = temp; printf("Value of x = %d and y = %d inside callByValue function.\n", x,y); } void callByReference(int *x, int *y) { int temp; temp = *x; *x = *y; *y = temp; }

We have learnt different types function C language and now I am going to explain recursive function in C. A function is called recursive if a statement within body of that function calls the same function for example look at below code: void main() { printf(recursive function called.\n); main(); } When you will run this program it will print message recursive function called. indefinitely. If you are using Turbo C/C++ compiler then you need to press Ctrl + Break key to break this in definite loop.

Recursive function example output

Before we move to another example lets have attributes of recursive function:1. A recursive function is a function which calls itself. 2. The speed of a recursive program is slower because of stack overheads. (This attribute is evident if you run above C program.) 3. A recursive function must have recursive conditions, terminating conditions, and recursive expressions.

Calculating factorial value using recursion

To understand how recursion works lets have another popular example of recursion. In this example we will calculate the factorial of n numbers. The factorial of n numbers is expressed as a series of repetitive multiplication as shown below: Factorial of n = n(n-1)(n-2)1. Example : Factiorial of 5 = 5x4x3x2x1 =120 #include<stdio.h>

10

#include<conio.h> int factorial(int); int factorial (int i) { int f; if(i==1) return 1; else f = i* factorial (i-1); return f; } void main() { int x; clrscr(); printf("Enter any number to calculate factorial :"); scanf("%d",&x); printf("\nFactorial : %d", factorial (x)); getch(); }

Factorial value using recursive function output

Read the Latest Electronics Design News & Daily Updates from EWSo from is a user defined recursive function factorial that calculates factorial of any given number. This function accepts integer type argument/parameter and return integer value. In we are checking that whether value of i is equal to 1 or not; i is an integer variable which contains value passed from main function i.e. value of integer variable x. If user enters 1 then the factorial of 1 will be 1. If user enters any value greater than 1 like 5 then it will execute statement in to calculate factorial of 5. This line is extremely important because in this line we implemented recursion logic. Lets see how exactly works. Suppose value of i=5, since i is not equal to 1, the statement: f = i* factorial (i-1); will be executed with i=5 i.e. f = 5* factorial (5-1); will be evaluated. As you can see this statement again calls factorial function with value i-1 which will return value: 4*factorial(4-1); This recursive calling continues until value of i is equal to 1 and when i is equal to 1 it returns 1 and execution of this function stops. We can review the series of recursive call as follow: f = 5* factorial (5-1); f = 5*4* factorial (4-1); f = 5*4*3* factorial (3-1); f = 5*4*3*2* factorial (2-1); f = 5*4*3*2*1; f = 120;

11

12