Function in C

We refer to a function as a group of various statements that perform a task together. Any C
program that we use has one function at least, that is main(). Then the programs can define
multiple additional functions in a code.

Table of Contents

● Use Of The Function In C

● Advantages Of Using Functions In C Programming
● Defining A Function In C
● Function Syntax
● Example
● Types Of Functions
● Return Value
● Function Calling – Different Aspects
● Declaration Of Function
● Calling Of A Function
● Function Arguments
● Library Functions In C
● Practice Problems On Function In C
● FAQs

Use of the Function in C

One can easily divide a C program code into several separate functions. How we divide our
available code according to different available functions is totally up to us. But the division
should occur logically in such a way that every function is capable of performing a specific task.

The declaration of function informs the compiler about the name of the function, parameters,
and return type. In other words, the function definition helps in providing the actual body of any
function that we want in a program/ code.

We can also refer to functions as a sub-routine, a method, or a procedure in a program. The

standard library in C language provides its users with various built-in functions that the
concerned programs can call. For example, we can use the strcat() function for concentrating
two strings, copy the location of one memory to another location of memory using the memcpy()
function, and many more.

Advantages of Using Functions in C Programming

The functions in the C programming language offer the following advantages to us:

● When we make use of the functions, then we can easily avoid the rewriting of the same
code/ logic time and again multiple times in any program.
● The calling of C functions may appear as many numbers of times as we want in any
program. And we can do so from any place in the program that is given to us.
● We can perform the tracking of a large C program pretty easily if we divide it into various
functions.
 ● One of the primary achievements of the C functions is reusability.
● However, remember that the function calling always acts as an overhead in the case of a
C program.

Defining a Function in C
The function definition, in general, holds this form in the C programming language:

return_type name_of_function( parameter list ) {

//function body

The function definition in the C programming language contains a function body and a function
header. Let us take a look at all the parts that a function consists of:

● Function Name − It denotes the actual name of any function that we are using in the
given code. The name and parameter of a function constitute a function signature in the
code together.
● Function Body − It consists of a collection of all the statements. These provide a
definition of what the function will do in the code.
● Parameters − It is just like a placeholder. Whenever we invoke a function, we pass a value
to the available parameter. We refer to this value as an argument or an actual parameter.
We refer to the parameter list as the number, order, and type of the function in the code.
The parameters may be optional. It means that any function in a code may consist of no
parameters at all.
● Return Type − We may get a value in return for a function. The term return type refers to
the data type of the returns that we get from the functions (function returns). Some of the
functions are also capable of performing any desired operation without getting a value in
return for it. In any such case, the keyword used for the return_type will be void.

Syntax of Function Aspects of Function

return_type name_of_function (argument list) { Function definition

//function body;

name_of_function (argument_list) Function call

 return_type name_of_function (argument list); Function declaration

Function Syntax
Here is the syntax that we use to create a function in the C programming language:

return_type name_of_function(data_type parameter…){

// executable code in c

Example
Here, we have given a source code below for the function max(). The max() function takes two of
the parameters- namely val1 and val2. It then returns the maximum value that is present between
both of them. Let us take a look:

/* the function returns the max in between two values */

int max(int val1, int val2) {

/* declaration of local variable */

int result;

if (val1 > val2)

result = val1;

else

result = val2;

return result;

Types of Functions
The C programming language has functions that are of the following types:

● User-defined Functions – These are the types of functions that we can create using the
C programmer so that we can make use of it multiple times. This function reduces the
complexity of any big program- and thus, optimizes the given code.
● Library Functions – These are the functions whose declaration occurs in the header files
of C, such as floor(), ceil(), outs(), gets(), printf(), scanf(), etc.

Return Value
Any function in the C programming may not return its value from any function. In case we don’t
need to return the value that is available in any function, we can make use of the void in the form
of a return type. Let us look at an example of the C function that does not perform the return of a
value from the available function.

Let us look at an example of a C function that has no return value:

void chocolate(){

printf(“chocolate c”);

In case we want to return a value from an available function, we must make use of any of the
data types, such as char, long, int, etc. Thus, the return type depends totally on the value that
needs to return from the available function. We will look at an example of a C function that will
return an int value from the given function.

Example of a C function with int return value,

int get(){

return 20;

In the example mentioned above, we are trying to return the value 20, and the data type, in this
case, is int. If we are willing to return to the value of the floating-point (example, 64.5, 7,9, 27.61,
etc.), then we must make use of the float in the form of the method’s return type.

float get(){

return 83.7;

Here, we have to call a function so that we get the function’s value.

Function Calling – Different Aspects

The functions available in a code may accept an argument or may not accept it at all. Thus, it
may return any of the values or may not do so. On the basis of these facts, the function calls
have the following four aspects:

● A function that has no arguments and has no return value.

● A function that has no arguments but has a return value.
● A function that has arguments but has no return value.
● A function that has arguments and also has a return value.

Example of a function that has no arguments and has no return value,

#include<stdio.h>

void printName();

void main ()

{
 printf(“Bye “);

printName();

void printName()

printf(“Kiddo”);

The output generated from this program would be:

Bye Kiddo

Example of a function that has no arguments but has a return value,

#include<stdio.h>

int sum();

void main()

printf(“By calculating the area of the square given\n”);

float area = square();

printf(“The area of the given square will be: %f\n”,area);

int square()

float side;

printf(“The length of the side of square in meters will be: “);

scanf(“%f”,&side);

return side * side;

The output generated from this program would be:

By calculating the area of the square given

The length of the side of the square in meters will be: 10

The area of the given square will be: 100.000000

Example of a function that has arguments but has no return value,

#include<stdio.h>
void sum(int, int);

void main()

int x,y,result;

printf(“\nCalculation of the sum of two values:”);

printf(“\nEntering of two values:”);

scanf(“%d %d”,&x,&y);

sum(x,y);

void sum(int x, int y)

printf(“\nThe sum of the two values is %d”,x+y);

The output generated from this program would be:

Calculation of the sum of two values:

Entering of two values 58

62

The sum of the two values is 120

Example of a function that has arguments and also has a return value,

#include<stdio.h>

int sum(int, int);

void main()

int x,y,result;

printf(“\nThe calculation of the sum of two values:”);

printf(“\nThe entering of two values:”);

scanf(“%d %d”,&x,&y);

result = sum(x,y);

printf(“\nThe sum is : %d”,result);

int sum(int x, int y)

{

return x+y;

The output generated from this program would be:

The calculation of the sum of two values:

The entering of two values: 49

51

The sum is: 100

Declaration of Function
The function definition basically tells a compiler about the name of the function and how one can
call this function. Then we can define the actual body of this function separately.

There are these following parts that exist in a function declaration:

return_type name_of_function( parameter list );

For the defined function above that is max(), the function declaration will occur in the following
way:

int max(int val1, int val2);

The parameter names are not that important in the case of function declaration- we only require
their type. Thus, the declaration mentioned below is also going to be valid:

int max(int, int);

We only require the declaration of the function when we define that function in a source file while
we still call that function in a separate file. In any such case, we have to declare that function at
the very top of the file that calls that function.

Calling of a Function
When we create a function in C programming, we basically provide that function with a definition
of what it has to do. But to use this function, we need to call this function for performing its
defined task.

When a function gets called by a program, the called function will get the program control
transferred to it. The called function will be performing a defined task. Once we execute the
return statement or when it reaches the closing brace of the function-ending, it is bound to return
the program control to the main program.

For calling a function, we simply have to pass the parameters required for it, along with the name
of the function. Here, if the function happens to return a value, then we can easily keep the
returned value stored with us.

For example −
#include <stdio.h>

/* declaration of function */

int max(int val1, int val2);

int main () {

/* definition of local variable */

int x = 400;

int y = 500;

int ret;

/* function calling for getting a max value */

ret = max(x, y);

printf( “The max value is : %d\n”, ret );

return 0;

/* function returns the max in between two values */

int max(int val1, int val2) {

/* declaration of local variable */

int result;

if (val1 > val2)

result = val1;

else

result = val2;

return result;

Output

In this case, we have kept the function max() with the function main(). After that, we have
performed the compilation of the source code. Running of the final executable would be
producing the result that follows:

The max value is: 500

Function Arguments
When a function needs to use the arguments, it has to declare those variables that happen to
accept the arguments’ values. Such variables are known as the given function’s formal
parameters.
The formal parameters behave just like any other local variables inside our given function. These
parameters get created when they enter into a function. After that, it gets destroyed when it exits.

During the calling of a function, there will be two ways in which we can perform the passing of
these arguments to a given function:

Type of Description of Call Type

Call

Call By The Call by Reference method creates a copy of the address of the
Reference given argument into the parameter that is formal in nature. Inside this
function, the use of address helps in accessing the actual argument
that comes in use in this call. It means that the changes that appear
on the parameter are bound to affect the given argument.

Call By The Call by Value method creates a copy of the actual value of the
Value given argument in the parameter of the function that is formal in
nature. Here, the changes that appear on the parameter (that exists
inside the function) create no effect whatsoever on the available
argument.

The C programming, by default, is the Call by Value for passing the arguments. Generally, it
means that we cannot make use of the code that exists within a function for altering the
arguments that help in calling the function.

Library Functions In C
The library functions in the C programming language are the inbuilt functions that are grouped
together and then placed in a common place known as the library. We make use of the library
functions to perform a specific type of operation. For example, the library function printf helps is
printing on the console. The designers of a compiler create the library functions. The defining of
all the standard library functions in C occurs inside multiple header files that are saved using the
.h extension.

A user needs to include such header files in their program for utilizing the library functions that
exist in those header files. For instance, if we want to make use of scanf/ printf library functions,
then we have to include the stdio.h header file in our program. This header file consists of all
library functions that relate to standard output/ input.

Here is a list of some of the header files that is mostly utilized in the C programming:
Header Header file’s Description
file

conio.h It is a type of console output/ input header file.

stdio.h It is a standard type of output/ input header file. This header file
consists of all the library functions that are related to standard output/
input.

stdlib.h It is a type of header file that consists of various general library

functions, such as exit(), calloc(), malloc(), etc.

string.h This header file consists of all the library functions that are
string-related, such as puts(), gets(), etc.

time.h It is a type of header file that consists of all the functions that are
time-related.

math.h It is a type of header file that consists of all the functions that are
related to the math operations, such as pow(), etc.

stdarg.h We use this header file for defining the variable argument functions.

ctype.h It is a type of header file that consists of the characters that handle the
functions.

setjmp.h It is a type of header file that consists of all the functions that are jump
functions.
 signal.h We use this header file for defining any given signal handling function.

errno.h This type of header file consists of all the error handling functions.

locale.h It is a type of header file that consists of alL the locale functions.

assert.h It is a type of header file that consists of all the diagnostic functions.

Practice Problems on Function in C

1. The declaration of which of these functions occurs in the header files of C?

A. Library functions

B. User-defined functions

C. Both

D. None

Answer – A. Library functions

2. Which of these is a part of a function?

1. Function Name

2. Function Body

3. Variable Space

4. Parameters

5. Return Type

A. 1, 2, 3, 4

B. 2, 4, 5

C. 1, 2, 4, 5

D. 2, 3, 5

E. None of the above

Answer – C. 1, 2, 4, 5

FAQs
What are the different aspects of function calls?

The functions available in a code may accept an argument or may not accept it at all. Thus, it
may return any of the values or may not do so. On the basis of these facts, the function calls
have the following four aspects:

● A function that has no arguments and has no return value.

● A function that has no arguments but has a return value.
● A function that has arguments but has no return value.
● A function that has arguments and also has a return value.

Why do we need to declare a function in a program?

The function definition basically tells a compiler about the name of the function and how one can
call this function. Then we can define the actual body of this function separately.

There are these following parts that exist in a function declaration:

return_type name_of_function( parameter list );

What is the importance of calling a function?

When we create a function in C programming, we basically provide that function with a definition
of what it has to do. But to use this function, we need to call this function for performing its
defined task.

When a function gets called by a program, the called function will get the program control
transferred to it. The called function will be performing a defined task. Once we execute the
return statement or when it reaches the closing brace of the function-ending, it is bound to return
back the program control to the main program.

For calling a function, we simply have to pass the parameters required for it, along with the name
of the function. Here, if the function happens to return a value, then we can easily keep the
returned value stored with us.