Functions IN CPROGRAMMING OF ENGINEERING.pptx

C functions
• In c, we can divide a large program into the basic building blocks known as function. The
function contains the set of programming statements enclosed by {}. A function can be
called multiple times to provide reusability and modularity to the C program. In other
words, we can say that the collection of functions creates a program. The function is also
known as procedure or subroutine in other programming languages.
Advantage of functions in C
• There are the following advantages of C functions.
• By using functions, we can avoid rewriting same logic/code again and again in a program.
• We can call C functions any number of times in a program and from any place in a
program.
• We can track a large C program easily when it is divided into multiple functions.
• Reusability is the main achievement of C functions.
• However, Function calling is always a overhead in a C program.

Function Aspects
• There are three aspects of a C function.
• Function declaration A function must be declared globally in a c program to tell
the compiler about the function name, function parameters, and return type.
•
Function call Function can be called from anywhere in the program. The
parameter list must not differ in function calling and function declaration. We must
pass the same number of parameters as it is declared in the function declaration.
•
Function definition It contains the actual statements which are to be executed. It
is the most important aspect to which the control comes when the function is
called. Here, we must notice that only one value can be returned from the function.

SN C function aspects Syntax
1 Function declaration return_type function_name (argument list);
2 Function call function_name (argument_list)
3 Function definition return_type function_name (argument list)
{function body;}
The syntax of creating function in c language is given
below
return_type function_name(data_type parameter...){
//code to be executed
}

Types of Functions
There are two types of functions in C programming:
1.Library Functions: are the functions which are declared in the C header files such as
scanf(), printf(), gets(), puts(), ceil(), floor() etc.
2.User-defined functions: are the functions which are created by the C programmer, so that
he/she can use it many times. It reduces the complexity of a big program and optimizes the
code

Return Value
• A C function may or may not return a value from the function. If you don't have to return any value from the function, use void for the return type.
• Let's see a simple example of C function that doesn't return any value from the function.
• Example without return value:
void hello(){
printf("hello c");
}
If you want to return any value from the function, you need to use any data type such as int, long, char, etc. The return type depends on the value to be returned from the function.
Let's see a simple example of C function that returns int value from the function.
Example with return value:
int get(){
return 10;
}
In the above example, we have to return 10 as a value, so the return type is int. If you want to return floating-point value (e.g., 10.2, 3.1, 54.5, etc), you need to use float as the return
type of the method.
float get(){
return 10.2;
}

Different aspects of function calling
• A function may or may not accept any argument. It may or may not return any
value. Based on these facts, There are four different aspects of function calls.
• function without arguments and without return value
• function without arguments and with return value
• function with arguments and without return value
• function with arguments and with return value

Example for Function without argument and return value
Example 1
• #include<stdio.h>
• void printName();
• void main ()
• {
• printf("Hello ");
• printName();
• }
• void printName()
• {
• printf(“Ayush");
• }
Output
• Hello Ayush

Example
1. #include<stdio.h>
2. void sum();
3. void main()
4. {
5. printf("nGoing to calculate the sum of two numbers:");
6. sum();
7. }
8. void sum()
9. {
10. int a,b;
11. printf("nEnter two numbers");
12. scanf("%d %d",&a,&b);
13. printf("The sum is %d",a+b);
14.}
Output
Going to calculate the sum of two numbers:
Enter two numbers 10
24
The sum is 34

Example for Function without argument and with return value
• int sum();
• void main()
• {
• int result;
• printf("nGoing to calculate the sum of two numbers:");
• result = sum();
• printf("%d",result);
• }
• int sum()
• {
• int a,b;
• printf("nEnter two numbers");
• scanf("%d %d",&a,&b);
• return a+b;
• }
Output:
24
The sum is 34

Example 2: program to calculate the area of the square
• int square();
• void main()
• {
• printf("Going to calculate the area of the squaren");
• float area = square();
• printf("The area of the square: %fn",area);
• }
• int square()
• {
• float side;
• printf("Enter the length of the side in meters: ");
• scanf("%f",&side);
• return side * side;
• }
Output
Going to calculate the area of the square
Enter the length of the side in meters: 10
The area of the square: 100.000000

Example for Function with argument and without return value
• void sum(int, int);
• void main()
• {
• int a,b,result;
• printf("nEnter two numbers:");
• scanf("%d %d",&a,&b);
• sum(a,b);
• }
• void sum(int a, int b)
• {
• printf("nThe sum is %d",a+b);
• }
Output
24
The sum is 34

Example : program to calculate the average of five numbers.
• void average(int, int, int, int, int);
• void main()
• {
• int a,b,c,d,e;
• printf("nGoing to calculate the average of five numbers:");
• printf("nEnter five numbers:");
• scanf("%d %d %d %d %d",&a,&b,&c,&d,&e);
• average(a,b,c,d,e);
• }
• void average(int a, int b, int c, int d, int e)
• {
• float avg;
• avg = (a+b+c+d+e)/5;
• printf("The average of given five numbers : %f",avg);
• }
Output
Going to calculate the average of five numbers:
Enter five numbers:10
20
30
40
50
The average of given five numbers : 30.000000

Example for Function with argument and with return value
Example
• int sum(int, int);
• void main()
• {
• int a,b,result;
• printf("nEnter two numbers:");
• scanf("%d %d",&a,&b);
• result = sum(a,b);
• printf("nThe sum is : %d",result);
• }
• int sum(int a, int b)
• {
• return a+b;
• }
Output
Enter two numbers:10
20
The sum is : 30

Example: Program to check whether a number is even or odd
1. #include<stdio.h>
2. int even_odd(int);
3. void main()
4. {
5. int n,flag=0;
6. printf("nGoing to check whether a number is even or odd");
7. printf("nEnter the number: ");
8. scanf("%d",&n);
9. flag = even_odd(n);
10. if(flag == 0)
11. {
12. printf("nThe number is odd");
13. }
14. else
15. {
16. printf("nThe number is even");
17. }
18.}

int even_odd(int n)
{
if(n%2 == 0)
{
return 1;
}
else
{
return 0;
}
}
Output
Going to check whether a number is even or odd
Enter the number: 100
The number is even

C Library Functions
• Library functions are the inbuilt function in C that are grouped and placed at a
common place called the library. Such functions are used to perform some specific
operations. For example, printf is a library function used to print on the console.
The library functions are created by the designers of compilers. All C standard
library functions are defined inside the different header files saved with the
extension .h. We need to include these header files in our program to make use of
the library functions defined in such header files. For example, To use the library
functions such as printf/scanf we need to include stdio.h in our program which is a
header file that contains all the library functions regarding standard input/output.

SN Header file Description
1 stdio.h This is a standard input/output header file. It contains all the library functions regarding standard
input/output.
2 conio.h This is a console input/output header file.
3 string.h It contains all string related library functions like gets(), puts(),etc.
4 stdlib.h This header file contains all the general library functions like malloc(), calloc(), exit(), etc.
5 math.h This header file contains all the math operations related functions like sqrt(), pow(), etc.
6 time.h This header file contains all the time-related functions.
7 ctype.h This header file contains all character handling functions.
8 stdarg.h Variable argument functions are defined in this header file.
9 signal.h All the signal handling functions are defined in this header file.
10 setjmp.h This file contains all the jump functions.
11 locale.h This file contains locale functions.
12 errno.h This file contains error handling functions.
13 assert.h This file contains diagnostics functions.

Call by value and Call by reference in C
• There are two methods to pass the data into the function in C language, i.e., call by value and call
by reference.

Call by value in C
• In call by value method, the value of the actual parameters is copied into the
formal parameters. In other words, we can say that the value of the variable is
used in the function call in the call by value method.
• In call by value method, we can not modify the value of the actual parameter by
the formal parameter.
• In call by value, different memory is allocated for actual and formal parameters
since the value of the actual parameter is copied into the formal parameter.
• The actual parameter is the argument which is used in the function call whereas
formal parameter is the argument which is used in the function definition.

Example : Concept of call by value
• void change(int num) {
• printf("Before adding value inside function num=%d n",num);
• num=num+100;
• printf("After adding value inside function num=%d n", num);
• }
• int main() {
• int x=100;
• printf("Before function call x=%d n", x);
• change(x);//passing value in function
• printf("After function call x=%d n", x);
• return 0;
• }
Output
Before function call x=100
Before adding value inside function num=100
After adding value inside function num=200
After function call x=100

Call by Value Example: Swapping the values of the two variables
• #include <stdio.h>
• void swap(int , int); //prototype of the function
• int main()
• {
• int a = 10;
• int b = 20;
• printf("Before swapping the values in main a = %d, b = %dn",a,b); // printing the value of a and b in main
• swap(a,b);
• printf("After swapping values in main a = %d, b = %dn",a,b); // The value of actual parameters do not change by changing the formal parameters in call by value, a = 10, b = 20
• }
• void swap (int a, int b)
• {
• int temp;
• temp = a;
• a=b;
• b=temp;
• printf("After swapping values in function a = %d, b = %dn",a,b); // Formal parameters, a = 20, b = 10
• }

Output
Before swapping the values in main a = 10, b = 20
After swapping values in function a = 20, b = 10
After swapping values in main a = 10, b = 20

Call by reference in C
• In call by reference, the address of the variable is passed into the function call as
the actual parameter.
• The value of the actual parameters can be modified by changing the formal
parameters since the address of the actual parameters is passed.
• In call by reference, the memory allocation is similar for both formal parameters
and actual parameters. All the operations in the function are performed on the
value stored at the address of the actual parameters, and the modified value gets
stored at the same address.

• void change(int *num) {
• printf("Before adding value inside function num=%d n",*num);
• (*num) += 100;
• printf("After adding value inside function num=%d n", *num);
• }
• int main() {
• int x=100;
• printf("Before function call x=%d n", x);
• change(&x);//passing reference in function
• printf("After function call x=%d n", x);
• return 0;
• }
Output
Before function call x=100
Before adding value inside function num=100
After adding value inside function num=200
After function call x=200

Call by reference Example: Swapping the values of the two variables
• #include <stdio.h>
• void swap(int *, int *); //prototype of the function
• int main()
• {
• int a = 10;
• int b = 20;
• printf("Before swapping the values in main a = %d, b = %dn",a,b); // printing the value of a and b in main
• swap(&a,&b);
• printf("After swapping values in main a = %d, b = %dn",a,b); // The values of actual parameters do change in call by reference, a = 10, b = 20
• }
• void swap (int *a, int *b)
• {
• int temp;
• temp = *a;
• *a=*b;
• *b=temp;
• printf("After swapping values in function a = %d, b = %dn",*a,*b); // Formal parameters, a = 20, b = 10
• }
Output
Before swapping the values in main a = 10, b = 20
After swapping values in function a = 20, b = 10
After swapping values in main a = 20, b = 10

Difference between call by value and call by reference in c
No. Call by value Call by reference
1 A copy of the value is
passed into the function
An address of value is passed
into the function
2 Changes made inside the
function is limited to the
function only. The values of
the actual parameters do
not change by changing the
formal parameters.
Changes made inside the
function validate outside of the
function also. The values of the
actual parameters do change by
changing the formal
parameters.
3 Actual and formal
arguments are created at
the different memory
location
Actual and formal arguments
are created at the same
memory location

Recursion
• Recursion is the process which comes into existence when a function calls a
copy of itself to work on a smaller problem. Any function which calls itself
is called recursive function, and such function calls are called recursive
calls. Recursion involves several numbers of recursive calls. However, it is
important to impose a termination condition of recursion. Recursion code is
shorter than iterative code however it is difficult to understand.
• Recursion cannot be applied to all the problem, but it is more useful for the
tasks that can be defined in terms of similar subtasks. For Example,
recursion may be applied to sorting, searching, and traversal problems.
• Generally, iterative solutions are more efficient than recursion since
function call is always overhead. Any problem that can be solved
recursively, can also be solved iteratively. However, some problems are best
suited to be solved by the recursion, for example, tower of Hanoi, Fibonacci
series, factorial finding, etc.

Recursion- factorial
1. #include <stdio.h>
2. int fact (int);
3. int main()
4. {
5. int n,f;
6. printf("Enter the number whose factorial you want to calculate?");
7. scanf("%d",&n);
8. f = fact(n);
9. printf("factorial = %d",f);
10. }
11. int fact(int n)
12. {
13. if (n==0)
14. {
15. return 0;
16. }
17. else if ( n == 1)
18. {
19. return 1;
20. }
21. else
22. {
23. return n*fact(n-1);
24. }
25. }

Output
Enter the number whose factorial you want to calculate?5
factorial = 120
We can understand the above program of the recursive method call by the figure given below:

Recursive Function
• A recursive function performs the tasks by dividing it into the
subtasks. There is a termination condition defined in the function
which is satisfied by some specific subtask. After this, the recursion
stops and the final result is returned from the function.
• The case at which the function doesn't recur is called the base case
whereas the instances where the function keeps calling itself to
perform a subtask, is called the recursive case. All the recursive
functions can be written using this format.

Pseudocode for writing any recursive function is given below.
• if (test_for_base)
• {
• return some_value;
• }
• else if (test_for_another_base)
• {
• return some_another_value;
• }
• else
• {
• // Statements;
• recursive call;
• }

Example of recursion to find the nth term of the Fibonacci series.
• int fibonacci(int);
• void main ()
• {
• int n,f;
• printf("Enter the value of n?");
• scanf("%d",&n);
• f = fibonacci(n);
• printf("%d",f);
• }
• int fibonacci (int n)
• {
• if (n==0)
• {
• return 0;
• }
• else if (n == 1)
• {
• return 1;
• }
• else
• {
• return fibonacci(n-1)+fibonacci(n-2);
• }
• }
Output
Enter the value of n?12
144

Memory allocation of Recursive method
• Each recursive call creates a new copy of that method in the memory.
Once some data is returned by the method, the copy is removed from
the memory. Since all the variables and other stuff declared inside
function get stored in the stack, therefore a separate stack is
maintained at each recursive call. Once the value is returned from the
corresponding function, the stack gets destroyed. Recursion involves
so much complexity in resolving and tracking the values at each
recursive call. Therefore we need to maintain the stack and track the
values of the variables defined in the stack.

Following example to understand the memory allocation of the
recursive functions.
• int display (int n)
• {
• if(n == 0)
• return 0; // terminating condition
• else
• {
• printf("%d",n);
• return display(n-1); // recursive call
• }
• }

• Let us examine this recursive function for n = 4. First, all the stacks are
maintained which prints the corresponding value of n until n becomes 0, Once the
termination condition is reached, the stacks get destroyed one by one by returning
0 to its calling stack. Consider the following image for more information regarding
the stack trace for the recursive functions.

Functions IN CPROGRAMMING OF ENGINEERING.pptx

Recommended

More Related Content

Similar to Functions IN CPROGRAMMING OF ENGINEERING.pptx (20)

Recently uploaded (20)

Functions IN CPROGRAMMING OF ENGINEERING.pptx