Functions in C Programming with Examples:

What is a Function?
A function in programming is a reusable block of code that makes a program easier to test,
understand and can be modified easily without changing the calling program. Functions to divide
the code and modularize the program for better and effective results. In short, a larger program is
divided into various subprograms which are called as functions.

When you divide a large program into various functions, it becomes easy to manage each
function individually. Whenever an error occurs in the program, you can easily investigate faulty
functions and correct only those errors. You can easily call and use functions whenever they are
required which automatically leads in saving time and space.

The advantages of using functions are:

 Avoid repetition of codes.
 Increases program readability.

 Divide a complex problem into simpler ones.

 Reduces chances of error.
 Modifying a program becomes easier by using function.

Library Vs. User-defined Functions

Every 'C' program has at least one function which is the main function, but a program can have
any number of functions. The main () function is a starting point of a program.

In 'C' programming, functions are divided into two types:

1. Library functions
2. User-defined functions

The difference between the library and user-defined functions is that we do not need to write a
code for a library function. It is already present inside the header file which we always include at
the beginning of a program. You just have to type the name of a function and use it along with
the proper syntax. Printf, scanf are the examples of a library function.

Whereas, a user-defined function is a type of function in which we have to write a body of a

function and call the function whenever we require the function to perform some operation in our
program.

A user-defined function is always written by the user, but later it can be a part of 'C' library. It is
a major advantage of 'C' programming.

In 'C' programming functions are divided into three activities such as,

1. Function declaration
2. Function definition
3. Function call

Function Declaration
Function declaration means writing a name of a program. It is a compulsory part for using
functions in code. In a function declaration, we just specify the name of a function that we are
going to use in our program like a variable declaration. We cannot use a function unless it is
declared in a program. A function declaration is also called "Function prototype."

The function declarations (called prototype) are usually done above the main () function and take
the general form:

return_data_type function_name (data_type arguments);

 The return_data_type: is the data type of the value function returned back to the calling
statement.
 The function_name: is followed by parentheses
 Arguments names with their data type declarations optionally are placed inside the
parentheses.

We consider the following program that shows how to declare a cube function to calculate the
cube value of an integer variable
#include <stdio.h>
/*Function declaration*/
int add(int a,b);
/*End of Function declaration*/
int main() {

Keep in mind that a function does not necessarily return a value. In this case, the keyword void is
used.

For example, the output_message function declaration indicates that the function does not return
a value: void output_message();

Function Definition
Function definition means just writing the body of a function. A body of a function consists of
statements which are going to perform a specific task. A function body consists of a single or a
block of statements. It is also a mandatory part of a function.

int add(int a,int b) //function body

{
int c;
c=a+b;
return c;
}

Function call
A function call means calling a function whenever it is required in a program. Whenever we call
a function, it performs an operation for which it was designed. A function call is an optional part
in a program.

result = add(4,5);

Here, is th complete code:

#include <stdio.h>
int add(int a, int b); //function declaration
int main()
{
int a=10,b=20;
int c=add(10,20); //function call
printf("Addition:%d\n",c);
getch();
}
int add(int a,int b) //function body
{
int c;
c=a+b;
return c;
}
Output:

Addition:30

Function Arguments
A function's arguments are used to receive the necessary values by the function call. They are
matched by position; the first argument is passed to the first parameter, the second to the second
parameter and so on.

By default, the arguments are passed by value in which a copy of data is given to the called
function. The actually passed variable will not change.

We consider the following program which demonstrates parameters passed by value:

int add (int x, int y);

int main() {
int a, b, result;
a = 5;
b = 10;
result = add(a, b);
printf("%d + %d\ = %d\n", a, b, result);
return 0;}
int add (int x, int y) {
x += y;
return(x);}

The program output is:

5 + 10 = 15

Keep in mind that the values of a and b were passed to add function were not changed because
only its value was passed into the parameter x.

Variable Scope
Variable scope means the visibility of variables within a code of the program.

In C, variables which are declared inside a function are local to that block of code and cannot be
referred to outside the function. However, variables which are declared outside all functions are
global and accessible from the entire program. Constants declared with a #define at the top of a
program are accessible from the entire program. We consider the following program which prints
the value of the global variable from both main and user defined function :

#include <stdio.h>
int global = 1348;
void test();
int main() {
 printf("from the main function : global =%d \n", global);
test () ;
return 0;}

void test (){

printf("from user defined function : global =%d \n", global);}

Result:

from the main function : global =1348

from user defined function : global =1348

We discuss the program details:

1. We declare an integer globale variable with 1348 as initial value.

2. We declare and define a test() function which neither takes arguments nor returns a value.
This function only prints the globale variable value to demonstrate that the global
variables can be accessed anywhere in the program.
3. We print the global variable within the main function.
4. We call the test function in orde to print the global variable value.

In C, when arguments are passed to function parameters, the parameters act as local variables
which will be destroyed when exiting the function.
When you use global variables, use them with caution because can lead to errors and they can
change anywhere in a program. They should be initialized before using.

Difference between Call by Value and Call by

Reference in C
Here you will learn about difference between call by value and call by
reference in C.

There are two different ways of passing values to functions: call by value
and call by reference. They are also called as pass by value and pass by
reference.

Call by Value in C
In call by value method a copy of actual parameters is passed which is
stored in formal parameters.

Actual Parameters: The parameters that are passed while calling the
function are called actual parameters.

Formal Parameters: The parameters that hold the values of actual

parameters are called formal parameters.

In call by value method, if any changes are done in formal parameters then
actual parameters are not changed.

Let’s take an example of call by value in C language.

Example:

#include<stdio.h>

#include<conio.h>

void fun(int x)

void main()

{
 int a=10;

printf("Before calling\na=%d",a);

fun(a);

printf("\n\nAfter calling\na=%d",a);

getch();

void fun(int x)

x=x+5;

Output:

OUTPUT:

Before calling a =10

After calling a=10

As you can clearly see in output that after calling the function and doing
changes in formal parameter x, the actual parameter a is not changed.

Call by Reference in C
In call by reference method, reference or address of actual parameters is
passed which is stored in formal parameters.

If any changes are done in formal parameters then actual parameters are
also changed.
Let’s take an example of call by reference in C language. You can clearly see
in output that after calling the function and doing changes in formal
parameter x, the actual parameter a is also changed.

Example:

 #include<stdio.h>

#include<conio.h>

void fun(int *x)

void main()

int a=10;

printf("Before calling\na=%d",a);

fun(&a);

printf("\n\nAfter calling\na=%d",a);

getch();

void fun(int *x)

*x=(*x)+5;

OUTPUT:

Before calling a =10

After calling a=15

You can clearly see in output that after calling the function and doing
changes in formal parameter x, the actual parameter a is also changed.

Call by value Call by reference

Parameters
While calling a function, when While calling a function, in programming
you pass values by copying language instead of copying the values of
Definition
variables, it is known as "Call By variables, the address of the variables is used it
Values." is known as "Call By References.
In this method, a copy of the
Arguments In this method, a variable itself is passed.
variable is passed.
Changes made in a copy of
Change in the variable also affects the value of
Effect variable never modify the value of
the variable outside the function.
variable outside the function.
Alteration of Does not allow you to make any Allows you to make changes in the values of
value changes in the actual variables. variables by using function calls.
Passing of Values of variables are passed Pointer variables are required to store the
variable using a straightforward method. address of variables.
Value
Original value not modified. The original value is modified.
modification
Actual and formal arguments will
Memory Actual and formal arguments will be created in
be created in different memory
Location the same memory location
location
Actual arguments remain safe as Actual arguments are not Safe. They can be
Safety they cannot be modified accidentally modified, so you need to handle
accidentally. arguments operations carefully.

Recursive Functions
Consider the factorial of a number which is calculated as follow 6! =6* 5 * 4 * 3 * 2 * 1.

This calculation is done as repeatedly calculating fact * (fact -1) until fact equals 1.

A recursive function is a function which calls itself and includes an exit condition in order to
finish the recursive calls. In the case of the factorial number calculation, the exit condition is fact
equals to 1. Recursion works by "stacking" calls until the exiting condition is true.

For example:
#include <stdio.h>
int factorial(int number);
int main() {
int x = 6;
printf("The factorial of %d is %d\n", x, factorial(x));
return 0;}
int factorial(int number) {
if (number == 1) return (1); /* exiting condition */
else
return (number * factorial(number - 1));
}

The program displays:

The factorial of 6 is 720

Here,we discuss program details:

1. We declare our recursive factorial function which takes an integer parameter and returns
the factorial of this parameter.This function will call itself and decrease the number until
the exiting, or the base condition is reached. When the condition is true, the previously
generated values will be multiplied by each other, and the final factorial value is returned.
2. We declare and initialize an integer variable with value"6" and then print its factorial
value by calling our factorial function.

Consider the following chart to more understand the recursive mechanism which consists of
calling the function its self until the base case or stopping condition is reached, and after that, we
collect the previous values:
Inline Functions
Functions are used to store the most frequently used instructions. It is used for modularizing the
program.
Whenever a function is called, the instruction pointer jumps to the function definition. After
executing a function, instruction pointer falls back to the statement from where it jumped to the
function definition.

Whenever we use functions, we require an extra pointer head to jump to the function definition
and return to the statement. To eliminate the need of such pointer heads, we use inline functions.

In an inline function, a function call is directly replaced by an actual program code. It does not
jump to any block because all the operations are performed inside the inline function.

Inline functions are mostly used for small computations. They are not suitable when large
computing is involved.

An inline function is similar to the normal function except that keyword inline is place before the
function name. Inline functions are created with the following syntax:

inline function_name ()
{
//function definition
}

Let us write a program to implement an inline function.

inline int add(int a, int b) //inline function declaration

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

Output:

Addition: 30

Above program demonstrates the use of an inline function for addition of two numbers. As we
can see, we have returned the addition on two numbers within the inline function only without
writing any extra lines. During function call we have just passed values on which we have to
perform addition.

Summary
 A function is a mini-program or a subprogram.
 Functions are used to modularize the program.
 Library and user-defined are two types of functions.
  A function consists of a declaration, function body, and a function call part.
 Function declaration and body are mandatory.
 A function call can be optional in a program.
 C program has at least one function; it is the main function ().
 Each function has a name, data type of return value or a void, parameters.
 Each function must be defined and declared in your C program.
 Keep in mind that ordinary variables in a C function are destroyed as soon as we exit the
function call.
 The arguments passed to a function will not be changed because they passed by value
none by address.
 The variable scope is referred to as the visibility of variables within a program
 There are global and local variables in C programming