C Functions
A function is a block of code that performs a specific task.
Suppose, you need to create a program to create a circle and color it. You can
create two functions to solve this problem:
● create a circle function
● create a color function
Dividing a complex problem into smaller chunks makes our program easy to
understand and reuse.
Types of function
There are two types of function in C programming:
● Standard library functions
● User-defined functions
Standard library functions
The standard library functions are built-in functions in C programming.
These functions are defined in header files. For example,
● The printf() is a standard library function to send formatted output to
the screen (display output on the screen). This function is defined in the
stdio.h header file.
Hence, to use the printf()function, we need to include the stdio.h
header file using #include <stdio.h>.
● The sqrt() function calculates the square root of a number. The function
is defined in the math.h header file.
Visit standard library functions in C programming to learn more.
User-defined function
You can also create functions as per your need. Such functions created by the
user are known as user-defined functions.
How user-defined function works?
#include <stdio.h>
void functionName()
{
... .. ...
... .. ...
}
int main()
{
... .. ...
... .. ...
functionName();
... .. ...
... .. ...
}
The execution of a C program begins from the main() function.
When the compiler encounters functionName();, control of the program jumps
to
void functionName()
And, the compiler starts executing the codes inside functionName().
The control of the program jumps back to the main() function once code inside
the function definition is executed.
Working of C Function
Note, function names are identifiers and should be unique.
This is just an overview of user-defined functions. Visit these pages to learn
more on:
● User-defined Function in C programming
● Types of user-defined Functions
Advantages of user-defined function
1. The program will be easier to understand, maintain and debug.
2. Reusable codes that can be used in other programs
3. A large program can be divided into smaller modules. Hence, a large
project can be divided among many programmers.
C User-defined functions
A function is a block of code that performs a specific task.
C allows you to define functions according to your need. These functions are
known as user-defined functions. For example:
Suppose, you need to create a circle and color it depending upon the radius
and color. You can create two functions to solve this problem:
● createCircle() function
● color() function
Example: User-defined function
Here is an example to add two integers. To perform this task, we have created
an user-defined addNumbers().
#include <stdio.h>
int addNumbers(int a, int b); // function prototype
int main()
{
int n1,n2,sum;
printf("Enters two numbers: ");
scanf("%d %d",&n1,&n2);
sum = addNumbers(n1, n2); // function call
printf("sum = %d",sum);
return 0;
}
int addNumbers(int a, int b) // function definition
{
int result;
result = a+b;
return result; // return statement
}
Function prototype
A function prototype is simply the declaration of a function that specifies
function's name, parameters and return type. It doesn't contain function body.
A function prototype gives information to the compiler that the function may
later be used in the program.
Syntax of function prototype
returnType functionName(type1 argument1, type2 argument2, ...);
In the above example, int addNumbers(int a, int b); is the function prototype
which provides the following information to the compiler:
1. name of the function is addNumbers()
2. return type of the function is int
3. two arguments of type int are passed to the function
The function prototype is not needed if the user-defined function is defined
before the main() function.
Calling a function
Control of the program is transferred to the user-defined function by calling it.
Syntax of function call
functionName(argument1, argument2, ...);
In the above example, the function call is made using addNumbers(n1, n2);
statement inside the main() function.
Function definition
Function definition contains the block of code to perform a specific task. In our
example, adding two numbers and returning it.
Syntax of function definition
returnType functionName(type1 argument1, type2 argument2, ...)
{
//body of the function
}
When a function is called, the control of the program is transferred to the
function definition. And, the compiler starts executing the codes inside the
body of a function.
Passing arguments to a function
In programming, argument refers to the variable passed to the function. In the
above example, two variables n1 and n2 are passed during the function call.
The parameters a and b accepts the passed arguments in the function
definition. These arguments are called formal parameters of the function.
Passing Argument to Function
The type of arguments passed to a function and the formal parameters must
match, otherwise, the compiler will throw an error.
If n1 is of char type, a also should be of char type. If n2 is of float type, variable
b also should be of float type.
A function can also be called without passing an argument.
Return Statement
The return statement terminates the execution of a function and returns a
value to the calling function. The program control is transferred to the calling
function after the return statement.
In the above example, the value of the result variable is returned to the main
function. The sum variable in the main() function is assigned this value.
Return Statement of Function
Syntax of return statement
return (expression);
For example,
return a;
return (a+b);
The type of value returned from the function and the return type specified in
the function prototype and function definition must match.
Types of User-defined Functions in
C Programming
These 4 programs below check whether the integer entered by the user is a
prime number or not.
The output of all these programs below is the same, and we have created a
user-defined function in each example. However, the approach we have taken
in each example is different.
Example 1: No Argument Passed and No Return Value
#include <stdio.h>
void checkPrimeNumber();
int main() {
checkPrimeNumber(); // argument is not passed
return 0;
}
// return type is void meaning doesn't return any value
void checkPrimeNumber() {
int n, i, flag = 0;
printf("Enter a positive integer: ");
scanf("%d",&n);
// 0 and 1 are not prime numbers
if (n == 0 || n == 1)
flag = 1;
for(i = 2; i <= n/2; ++i) {
if(n%i == 0) {
flag = 1;
break;
}
}
if (flag == 1)
printf("%d is not a prime number.", n);
else
printf("%d is a prime number.", n);
}
Run Code
The checkPrimeNumber() function takes input from the user, checks whether it
is a prime number or not, and displays it on the screen.
The empty parentheses in checkPrimeNumber(); inside the main() function
indicates that no argument is passed to the function.
The return type of the function is void. Hence, no value is returned from the
function.
Example 2: No Arguments Passed But Returns a Value
#include <stdio.h>
int getInteger();
int main() {
int n, i, flag = 0;
// no argument is passed
n = getInteger();
// 0 and 1 are not prime numbers
if (n == 0 || n == 1)
flag = 1;
for(i = 2; i <= n/2; ++i) {
if(n%i == 0){
flag = 1;
break;
}
}
if (flag == 1)
printf("%d is not a prime number.", n);
else
printf("%d is a prime number.", n);
return 0;
}
// returns integer entered by the user
int getInteger() {
int n;
printf("Enter a positive integer: ");
scanf("%d",&n);
return n;
}
Run Code
The empty parentheses in the n = getInteger(); statement indicates that no
argument is passed to the function. And, the value returned from the function
is assigned to n.
Here, the getInteger() function takes input from the user and returns it. The
code to check whether a number is prime or not is inside the main() function.
Example 3: Argument Passed But No Return Value
#include <stdio.h>
void checkPrimeAndDisplay(int n);
int main() {
int n;
printf("Enter a positive integer: ");
scanf("%d",&n);
// n is passed to the function
checkPrimeAndDisplay(n);
return 0;
}
// return type is void meaning doesn't return any value
void checkPrimeAndDisplay(int n) {
int i, flag = 0;
// 0 and 1 are not prime numbers
if (n == 0 || n == 1)
flag = 1;
for(i = 2; i <= n/2; ++i) {
if(n%i == 0){
flag = 1;
break;
}
}
if(flag == 1)
printf("%d is not a prime number.",n);
else
printf("%d is a prime number.", n);
}
Run Code
The integer value entered by the user is passed to the checkPrimeAndDisplay()
function.
Here, the checkPrimeAndDisplay() function checks whether the argument
passed is a prime number or not and displays the appropriate message.
Example 4: Argument Passed and Returns a Value
#include <stdio.h>
int checkPrimeNumber(int n);
int main() {
int n, flag;
printf("Enter a positive integer: ");
scanf("%d",&n);
// n is passed to the checkPrimeNumber() function
// the returned value is assigned to the flag variable
flag = checkPrimeNumber(n);
if(flag == 1)
printf("%d is not a prime number",n);
else
printf("%d is a prime number",n);
return 0;
}
// int is returned from the function
int checkPrimeNumber(int n) {
// 0 and 1 are not prime numbers
if (n == 0 || n == 1)
return 1;
int i;
for(i=2; i <= n/2; ++i) {
if(n%i == 0)
return 1;
}
return 0;
}
Run Code
The input from the user is passed to the checkPrimeNumber() function.
The checkPrimeNumber() function checks whether the passed argument is
prime or not.
If the passed argument is a prime number, the function returns 0. If the
passed argument is a non-prime number, the function returns 1. The return
value is assigned to the flag variable.
Depending on whether flag is 0 or 1, an appropriate message is printed from
the main() function.
Which approach is better?
Well, it depends on the problem you are trying to solve. In this case, passing
an argument and returning a value from the function (example 4) is better.
A function should perform a specific task. The checkPrimeNumber() function
doesn't take input from the user nor it displays the appropriate message. It
only checks whether a number is prime or not.
C Recursion
A function that calls itself is known as a recursive function. And, this technique
is known as recursion.
How recursion works?
void recurse()
{
... .. ...
recurse();
... .. ...
}
int main()
{
... .. ...
recurse();
... .. ...
}
Working of
Recursion
The recursion continues until some condition is met to prevent it.
To prevent infinite recursion, if...else statement (or similar approach) can be
used where one branch makes the recursive call, and other doesn't.
Example: Sum of Natural Numbers Using Recursion
#include <stdio.h>
int sum(int n);
int main() {
int number, result;
printf("Enter a positive integer: ");
scanf("%d", &number);
result = sum(number);
printf("sum = %d", result);
return 0;
}
int sum(int n) {
if (n != 0)
// sum() function calls itself
return n + sum(n-1);
else
return n;
}
Output
Enter a positive integer:3
sum = 6
Initially, the sum() is called from the main() function with number passed as an
argument.
Suppose, the value of n inside sum() is 3 initially. During the next function call,
2 is passed to the sum() function. This process continues until n is equal to 0.
When n is equal to 0, the if condition fails and the else part is executed
returning the sum of integers ultimately to the main() function.
Sum of Natural Numbers
Advantages and Disadvantages of Recursion
Recursion makes program elegant. However, if performance is vital, use loops
instead as recursion is usually much slower.
That being said, recursion is an important concept. It is frequently used in data
structure and algorithms. For example, it is common to use recursion in
problems such as tree traversal.
C Standard Library Functions
C Standard library functions or simply C Library functions are inbuilt functions
in C programming.
The prototype and data definitions of these functions are present in their
respective header files. To use these functions we need to include the header
file in our program. For example,
If you want to use the printf() function, the header file <stdio.h> should be
included.
#include <stdio.h>
int main()
{
printf("Catch me if you can.");
}
If you try to use printf() without including the stdio.h header file, you will get
an error.
Advantages of Using C library functions
1. They work
One of the most important reasons you should use library functions is simply
because they work. These functions have gone through multiple rigorous
testing and are easy to use.
2. The functions are optimized for performance
Since, the functions are "standard library" functions, a dedicated group of
developers constantly make them better. In the process, they are able to
create the most efficient code optimized for maximum performance.
3. It saves considerable development time
Since the general functions like printing to a screen, calculating the square
root, and many more are already written. You shouldn't worry about creating
them once again.
4. The functions are portable
With ever-changing real-world needs, your application is expected to work
every time, everywhere. And, these library functions help you in that they do
the same thing on every computer.
Example: Square root using sqrt() function
Suppose, you want to find the square root of a number.
To compute the square root of a number, you can use the sqrt() library
function. The function is defined in the math.h header file.
#include <stdio.h>
#include <math.h>
int main()
{
float num, root;
printf("Enter a number: ");
scanf("%f", &num);
// Computes the square root of num and stores in root.
root = sqrt(num);
printf("Square root of %.2f = %.2f", num, root);
return 0;
}
When you run the program, the output will be:
Enter a number: 12
Square root of 12.00 = 3.46
