FUNCTIONS

A function in C is a set of statements that when called perform some

specific task. It is the basic building block of a C program that provides
modularity and code reusability. The programming statements of a
function are enclosed within { } braces, having certain meanings and
performing certain operations. They are also called subroutines or
procedures in other languages.
In this article, we will learn about functions, function definition.
declaration, arguments and parameters, return values, and many more.
Syntax of Functions in C
The syntax of function can be divided into 3 aspects:
1. Function Declaration
2. Function Definition
3. Function Calls

1. Function Declarations
In a function declaration, we must provide the function name, its return
type, and the number and type of its parameters. A function declaration
tells the compiler that there is a function with the given name defined
somewhere else in the program.
Syntax
return_type name_of_the_function (parameter_1, parameter_2);

The parameter name is not mandatory while declaring functions. We can

also declare the function without using the name of the data variables.
Example
int sum(int a, int b); // Function declaration with parameter
names
int sum(int , int); // Function declaration without parameter
names
 2. Function Definition
The function definition consists of actual statements which are executed
when the function is called (i.e. when the program control comes to the
function).
A C function is generally defined and declared in a single step because
the function definition always starts with the function declaration so we
do not need to declare it explicitly. The below example serves as both a
function definition and a declaration.
return_type function_name (para1_type para1_name, para2_type
para2_name)
{
// body of the function
}
 3. Function Call
A function call is a statement that instructs the compiler to execute the
function. We use the function name and parameters in the function call.
In the below example, the first sum function is called and 10,30 are
passed to the sum function. After the function call sum of a and b is
returned and control is also returned back to the main function of the
program.

Function Return Type

Function return type tells what type of value is returned after all function
is executed. When we don’t want to return a value, we can use the void
data type.
Example:
int func(parameter_1,parameter_2);
The above function will return an integer value after running statements
inside the function.
Conditions of Return Types and Arguments

In C programming language, functions can be called either with or without

arguments and might return values. They may or might not return values
to the calling functions.

1. Function with no arguments and no return value

 2. Function with no arguments and with return value

3. Function with argument and with no return value

4. Function with arguments and with return value

How Does C Function Work?

Working of the C function can be broken into the following steps as

mentioned below:

1. Declaring a function: Declaring a function is a step where we

declare a function. Here we define the return types and parameters
of the function.

2. Defining a function:

3. Calling the function: Calling the function is a step where we call the
function by passing the arguments in the function.

4. Executing the function: Executing the function is a step where we

can run all the statements inside the function to get the final result.

5. Returning a value: Returning a value is the step where the

calculated value after the execution of the function is returned.
Exiting the function is the final step where all the allocated memory
to the variables, functions, etc is destroyed before giving full control
to the main function.

Types of Functions

There are two types of functions in C:

1. Library Functions

2. User Defined Functions

Library Function

A library function is also referred to as a “built-in function”. A compiler

package already exists that contains these functions, each of which has a
specific meaning and is included in the package. Built-in functions have
the advantage of being directly usable without being defined, whereas
user-defined functions must be declared and defined before being used.
For Example:

pow(), sqrt(), strcmp(), strcpy() etc.

Advantages of C library functions

• C Library functions are easy to use and optimized for better

performance.

• C library functions save a lot of time i.e, function development time.

• C library functions are convenient as they always work.

2. User Defined Function

Functions that the programmer creates are known as User-Defined

functions or “tailor-made functions”. User-defined functions can be
improved and modified according to the need of the programmer.
Whenever we write a function that is case-specific and is not defined in
any header file, we need to declare and define our own functions
according to the syntax.

Advantages of User-Defined Functions

• Changeable functions can be modified as per need.

• The Code of these functions is reusable in other programs.

• These functions are easy to understand, debug and maintain.

Example-
// C program to show user-defined functions

#include <stdio.h>

int sum(int a, int b)

return a + b;

int main()

int a = 30, b = 40;

// function call
 int res = sum(a, b);

printf("Sum is: %d", res);

return 0;

Output-

Sum is:70

Passing Parameters to Functions

The data passed when the function is being invoked is known as the
Actual parameters. In the below program, 10 and 30 are known as actual
parameters. Formal Parameters are the variable and the data type as
mentioned in the function declaration. In the below program, a and b are
known as formal parameters.

We can pass arguments to the C function in two ways:

1. Pass by Value

2. Pass by Reference
1. Pass by Value

Parameter passing in this method copies values from actual parameters

into formal function parameters. As a result, any changes made inside the
functions do not reflect in the caller’s parameters.

Example:
// C program to show use of call by value

#include <stdio.h>

void swap(int var1, int var2)

int temp = var1;

var1 = var2;

var2 = temp;

int main()

int var1 = 3, var2 = 2;

printf("Before swap Value of var1 and var2 is: %d, %d\n",

var1, var2);

swap(var1, var2);

printf("After swap Value of var1 and var2 is: %d, %d",

var1, var2);

return 0;

Output

Before swap Value of var1 and var2 is: 3, 2

After swap Value of var1 and var2 is: 3, 2

2. Pass by Reference

The caller’s actual parameters and the function’s actual parameters refer
to the same locations, so any changes made inside the function are
reflected in the caller’s actual parameters.
Example:

// C program to show use of call by Reference

#include <stdio.h>

void swap(int *var1, int *var2)

int temp = *var1;

*var1 = *var2;

*var2 = temp;

int main()

int var1 = 3, var2 = 2;

printf("Before swap Value of var1 and var2 is: %d, %d\n",

var1, var2);

swap(&var1, &var2);

printf("After swap Value of var1 and var2 is: %d, %d",

var1, var2);

return 0;

Output

Before swap Value of var1 and var2 is: 3, 2

After swap Value of var1 and var2 is: 2, 3

Advantages of Functions

Functions in C is a highly useful feature of C with many advantages as

mentioned below:

1. The function can reduce the repetition of the same statements in the
program.

2. The function makes code readable by providing modularity to our

program.
 3. There is no fixed number of calling functions it can be called as
many times as you want.

4. The function reduces the size of the program.

5. Once the function is declared you can just use it without thinking
about the internal working of the function.

Disadvantages of Functions

The following are the major disadvantages of functions in C:

1. Cannot return multiple values.

2. Memory and overhead due to stack frame allocation and transfer of

program control.

Scope of a Variable:-

The scope of a variable in a program defines where and for how long that
variable is valid and accessible. In essence, it sets the boundaries within
which the variable can be utilized.

Variables have their scope determined at the time of declaration and

can be categorized into two primary types:

1. Global Scope of a Variable:

o Global variables are declared outside of any function or block

of code and can be accessed from any part of the program.

o They have a broader scope and are visible in every part of the
program.

o Global variables are also known as file-scope variables

because their scope starts at the beginning of the file and ends
at the end of the file.
 o Example:

#include <stdio.h>

int global = 5; // Global variable

void display() {

printf("%d\n", global);

int main() {

printf("Before change within main: ");

display();

global = 10;

printf("After change within main: ");

display();

return 0;

Output:

Before change within main: 5

After change within main: 10

2. Local Scope of a Variable:

o Local scope refers to the region inside a block or a function

(enclosed between { } braces).

o Variables declared within local scope are called local

variables.

o Local variables are visible only within the block they are
declared in and any nested blocks inside that block.
o Example:

#include <stdio.h>

int main() {
 {

int x = 10, y = 20;

printf("x = %d, y = %d\n", x, y); // 10 and 20

int y = 40;

x++;

y++;

printf("x = %d, y = %d\n", x, y); // 11 and 41

printf("x = %d, y = %d\n", x, y); // 11 and 20

return 0;

Output:

x = 10, y = 20

x = 11, y = 41

x = 11, y = 20

o Local variables have internal linkage.

Remember that global variables are accessible throughout the program,

while local variables are limited to their specific scope.

Global vs. Local Variables :-

Feature Global Variable Local Variable

Declared outside all

Declared within a
Declaration functions, usually at the
function
top of the code
 Accessible only within
Accessible by all
Scope the function it is
functions in the program
declared in

Created when function

Exists for entire duration
Lifetime is called, destroyed
of program execution
when function exits

Can only be accessed

Can be accessed by any
Accessibility within the function it is
function in the program
declared in

Automatically initialized
Default Contains garbage value
to 0 if not explicitly
Initialization if not explicitly initialized
initialized

Stored in data segment of Stored in stack segment

Memory
memory of memory

Can have same name in

Naming Must have unique names
different functions
Example Illustrating Differences