Decision Making in C (if , if..

else, Nested if, if-else-if )




The conditional statements (also known as decision control structures) such as if, if
else, switch, etc. are used for decision-making purposes in C programs.
They are also known as Decision-Making Statements and are used to evaluate one or
more conditions and make the decision whether to execute a set of statements or not.
These decision-making statements in programming languages decide the direction of
the flow of program execution.
Need of Conditional Statements
There come situations in real life when we need to make some decisions and based on
these decisions, we decide what should we do next. Similar situations arise in
programming also where we need to make some decisions and based on these decisions
we will execute the next block of code. For example, in C if x occurs then execute y else
execute z. There can also be multiple conditions like in C if x occurs then execute p, else
if condition y occurs execute q, else execute r. This condition of C else-if is one of the
many ways of importing multiple conditions.
Types of Conditional Statements in C

Following are the decision-making statements available in C:

1. if Statement
2. if-else Statement
3. Nested if Statement
4. if-else-if Ladder
5. switch Statement
6. Conditional Operator
7. Jump Statements:

 break
 continue
  goto
 return
Let’s discuss each of them one by one.
1. if in C
The if statement is the most simple decision-making statement. It is used to decide
whether a certain statement or block of statements will be executed or not i.e if a
certain condition is true then a block of statements is executed otherwise not.
Syntax of if Statement
if(condition)
{
// Statements to execute if
// condition is true
}
Here, the condition after evaluation will be either true or false. C if statement accepts
boolean values – if the value is true then it will execute the block of statements below it
otherwise not. If we do not provide the curly braces ‘{‘ and ‘}’ after if(condition) then by
default if statement will consider the first immediately below statement to be inside its
block.
Flowchart of if Statement

Flow Diagram of if Statement

Example of if in C
C
// C program to illustrate If statement
#include <stdio.h>

int main()
{
int i = 10;

if (i > 15) {
printf("10 is greater than 15");
}

printf("I am Not in if");

}

Output
I am Not in if
As the condition present in the if statement is false. So, the block below the if statement
is not executed.
2. if-else in C
The if statement alone tells us that if a condition is true it will execute a block of
statements and if the condition is false it won’t. But what if we want to do something
else when the condition is false? Here comes the C else statement. We can use
the else statement with the if statement to execute a block of code when the condition is
false. The if-else statement consists of two blocks, one for false expression and one for
true expression.
Syntax of if else in C
if (condition)
{
// Executes this block if
// condition is true
}
else
{
// Executes this block if
// condition is false
}
Flowchart of if-else Statement

Flow Diagram of if else

Example of if-else
C
// C program to illustrate If statement
#include <stdio.h>

int main()
{
int i = 20;

if (i < 15) {

printf("i is smaller than 15");

}
else {

printf("i is greater than 15");

}
return 0;
}

Output
i is greater than 15
The block of code following the else statement is executed as the condition present in
the if statement is false.

3. Nested if-else in C
A nested if in C is an if statement that is the target of another if statement. Nested if
statements mean an if statement inside another if statement. Yes, C allow us to nested if
statements within if statements, i.e, we can place an if statement inside another if
statement.
Syntax of Nested if-else
if (condition1)
{
// Executes when condition1 is true
if (condition_2)
{
// statement 1
}
else
{
// Statement 2
}
}
else {
if (condition_3)
{
// statement 3
}
else
{
// Statement 4
}
}
The below flowchart helps in visualize the above syntax.
Flowchart of Nested if-else
Example of Nested if-else
C
// C program to illustrate nested-if statement
#include <stdio.h>

int main()
{
int i = 10;

if (i == 10) {
// First if statement
if (i < 15)
printf("i is smaller than 15\n");

// Nested - if statement
// Will only be executed if statement above
// is true
if (i < 12)
printf("i is smaller than 12 too\n");
else
printf("i is greater than 15");
}
else {
if (i == 20) {

// Nested - if statement
// Will only be executed if statement above
// is true
if (i < 22)
printf("i is smaller than 22 too\n");
else
printf("i is greater than 25");
}
}

return 0;
}
Output
i is smaller than 15
i is smaller than 12 too
4. if-else-if Ladder in C
The if else if statements are used when the user has to decide among multiple options.
The C if statements are executed from the top down. As soon as one of the conditions
controlling the if is true, the statement associated with that if is executed, and the rest
of the C else-if ladder is bypassed. If none of the conditions is true, then the final else
statement will be executed. if-else-if ladder is similar to the switch statement.
Syntax of if-else-if Ladder
if (condition)
statement;
else if (condition)
statement;
.
.
else
statement;
Flowchart of if-else-if Ladder

Flow Diagram of if-else-if

Example of if-else-if Ladder

C
// C program to illustrate nested-if statement
#include <stdio.h>

int main()
{
int i = 20;

if (i == 10)
printf("i is 10");
else if (i == 15)
printf("i is 15");
else if (i == 20)
printf("i is 20");
else
printf("i is not present");
}
Output
i is 20
5. switch Statement in C
The switch case statement is an alternative to the if else if ladder that can be used to
execute the conditional code based on the value of the variable specified in the switch
statement. The switch block consists of cases to be executed based on the value of the
switch variable.
Syntax of switch
switch (expression) {
case value1:
statements;
case value2:
statements;
....
....
....
default:
statements;
}
Note: The switch expression should evaluate to either integer or character. It cannot
evaluate any other data type.

Flowchart of switch

Flowchart of switch in C

Example of switch Statement

C
// C Program to illustrate the use of switch statement
#include <stdio.h>
int main()
{
// variable to be used in switch statement
int var = 2;

// declaring switch cases

switch (var) {
case 1:
printf("Case 1 is executed");
break;
case 2:
printf("Case 2 is executed");
break;
default:
printf("Default Case is executed");
break;
}

return 0;
}

Output
Case 2 is executed
6. Conditional Operator in C
The conditional operator is used to add conditional code in our program. It is similar to
the if-else statement. It is also known as the ternary operator as it works on three
operands.
Syntax of Conditional Operator
(condition) ? [true_statements] : [false_statements];
Flowchart of Conditional Operator

Flow Diagram of Conditional Operator

Example of Conditional Operator

C
// C Program to illustrate the use of conditional operator
#include <stdio.h>

// driver code
int main()
{
 int var;
int flag = 0;

// using conditional operator to assign the value to var

// according to the value of flag
var = flag == 0 ? 25 : -25;
printf("Value of var when flag is 0: %d\n", var);

// changing the value of flag

flag = 1;
// again assigning the value to var using same statement
var = flag == 0 ? 25 : -25;
printf("Value of var when flag is NOT 0: %d", var);

return 0;
}

Output
Value of var when flag is 0: 25
Value of var when flag is NOT 0: -25
7. Jump Statements in C
These statements are used in C for the unconditional flow of control throughout the
functions in a program. They support four types of jump statements:
A) break
This loop control statement is used to terminate the loop. As soon as
the break statement is encountered from within a loop, the loop iterations stop there,
and control returns from the loop immediately to the first statement after the loop.
Syntax of break
break;
Basically, break statements are used in situations when we are not sure about the actual
number of iterations for the loop or we want to terminate the loop based on some
condition.

Example of break
C
// C program to illustrate
// to show usage of break
// statement
#include <stdio.h>
void findElement(int arr[], int size, int key)
{
// loop to traverse array and search for key
for (int i = 0; i < size; i++) {
if (arr[i] == key) {
printf("Element found at position: %d",
(i + 1));
break;
}
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6 };

// no of elements
int n = 6;

// key to be searched
int key = 3;
// Calling function to find the key
findElement(arr, n, key);
return 0;
}

Output
Element found at position: 3
B) continue
This loop control statement is just like the break statement. The continue statement is
opposite to that of the break statement, instead of terminating the loop, it forces to
execute the next iteration of the loop.
As the name suggests the continue statement forces the loop to continue or execute the
next iteration. When the continue statement is executed in the loop, the code inside the
loop following the continue statement will be skipped and the next iteration of the loop
will begin.
Syntax of continue
continue;
Flowchart of Continue

Example of continue
C
// C program to explain the use
// of continue statement
#include <stdio.h>
int main()
{
// loop from 1 to 10
for (int i = 1; i <= 10; i++) {

// If i is equals to 6,
// continue to next iteration
// without printing
if (i == 6)
continue;

else
// otherwise print the value of i
printf("%d ", i);
}
return 0;
}

Output
1 2 3 4 5 7 8 9 10
If you create a variable in if-else in C, it will be local to that if/else block only. You can
use global variables inside the if/else block. If the name of the variable you created in
if/else is as same as any global variable then priority will be given to the `local
variable`.
C
#include <stdio.h>
int main()
{

int gfg = 0; // local variable for main

printf("Before if-else block %d\n", gfg);
if (1) {
int gfg = 100; // new local variable of if block
printf("if block %d\n", gfg);
}
printf("After if block %d", gfg);
return 0;
}

Output
Before if-else block 0
if block 100
After if block 0
C) goto
The goto statement in C also referred to as the unconditional jump statement can be
used to jump from one point to another within a function.
Syntax of goto
Syntax1 | Syntax2
----------------------------
goto label; | label:
. | .
. | .
. | .
label: | goto label;
In the above syntax, the first line tells the compiler to go to or jump to the statement
marked as a label. Here, a label is a user-defined identifier that indicates the target
statement. The statement immediately followed after ‘label:’ is the destination
statement. The ‘label:’ can also appear before the ‘goto label;’ statement in the above
syntax.

Examples of goto
C
// C program to print numbers
// from 1 to 10 using goto
// statement
#include <stdio.h>
// function to print numbers from 1 to 10
void printNumbers()
{
int n = 1;
label:
printf("%d ", n);
n++;
if (n <= 10)
goto label;
}
// Driver program to test above function
int main()
{
printNumbers();
return 0;
}

Output
1 2 3 4 5 6 7 8 9 10
D) return
The return in C returns the flow of the execution to the function from where it is called.
This statement does not mandatorily need any conditional statements. As soon as the
statement is executed, the flow of the program stops immediately and returns the
control from where it was called. The return statement may or may not return anything
for a void function, but for a non-void function, a return value must be returned.
Flowchart of return

Flow Diagram of return

Syntax of return
return [expression];
Example of return
C
// C code to illustrate return
// statement
#include <stdio.h>

// non-void return type

// function to calculate sum
 int SUM(int a, int b)
{
int s1 = a + b;
return s1;
}

// returns void
// function to print
void Print(int s2)
{
printf("The sum is %d", s2);
return;
}

int main()
{
int num1 = 10;
int num2 = 10;
int sum_of = SUM(num1, num2);
Print(sum_of);
return 0;
}

Output
The sum is 20

C – Loops





Loops in programming are used to repeat a block of code until the specified condition is
met. A loop statement allows programmers to execute a statement or group of
statements multiple times without repetition of code.

// C program to illustrate need of loops

#include <stdio.h>

int main()
{
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");
printf( "Hello World\n");

return 0;
}

Output
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
There are mainly two types of loops in C Programming:
1. Entry Controlled loops: In Entry controlled loops the test condition is checked
before entering the main body of the loop. For Loop and While Loop is Entry-
controlled loops.
2. Exit Controlled loops: In Exit controlled loops the test condition is evaluated at the
end of the loop body. The loop body will execute at least once, irrespective of whether
the condition is true or false. do-while Loop is Exit Controlled loop.

Loop Type Description

first Initializes, then condition check, then executes the body and at last, the update is
for loop
done.

first Initializes, then condition checks, and then executes the body, and updating can be
while loop
inside the body.

do-while
do-while first executes the body and then the condition check is done.
loop

for Loop
for loop in C programming is a repetition control structure that allows programmers to
write a loop that will be executed a specific number of times. for loop enables
programmers to perform n number of steps together in a single line.
Syntax:
for (initialize expression; test expression; update expression)
{
//
// body of for loop
 //
}
Example:
for(int i = 0; i < n; ++i)
{
printf("Body of for loop which will execute till n");
}
In for loop, a loop variable is used to control the loop. Firstly we initialize the loop
variable with some value, then check its test condition. If the statement is true then
control will move to the body and the body of for loop will be executed. Steps will be
repeated till the exit condition becomes true. If the test condition will be false then it will
stop.
 Initialization Expression: In this expression, we assign a loop variable or loop
counter to some value. for example: int i=1;
 Test Expression: In this expression, test conditions are performed. If the condition
evaluates to true then the loop body will be executed and then an update of the loop
variable is done. If the test expression becomes false then the control will exit from
the loop. for example, i<=9;
 Update Expression: After execution of the loop body loop variable is updated by
some value it could be incremented, decremented, multiplied, or divided by any
value.
for loop Equivalent Flow Diagram:
Example:
// C program to illustrate for loop
#include <stdio.h>
// Driver code
int main()
{
int i = 0;

for (i = 1; i <= 10; i++)

{
printf( "Hello World\n");
}
return 0;
}

Output
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
While Loop
While loop does not depend upon the number of iterations. In for loop the number of
iterations was previously known to us but in the While loop, the execution is terminated
on the basis of the test condition. If the test condition will become false then it will break
from the while loop else body will be executed.
Syntax:
initialization_expression;

while (test_expression)
{
// body of the while loop

update_expression;
}
Flow Diagram for while loop:
 #include <stdio.h>

// Driver code
int main()
{
// Initialization expression
int i = 2;

// Test expression
while(i < 10)
{
// loop body
printf( "Hello World\n");

// update expression
i++;
}

return 0;
}

Output
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
do-while Loop
The do-while loop is similar to a while loop but the only difference lies in the do-while
loop test condition which is tested at the end of the body. In the do-while loop, the loop
body will execute at least once irrespective of the test condition.
Syntax:
initialization_expression;
do
{
 // body of do-while loop

update_expression;
} while (test_expression);

#include <stdio.h>

// Driver code
int main()
{
// Initialization expression
int i = 2;

do
{
// loop body
printf( "Hello World\n");

// Update expression
i++;

// Test expression
} while (i < 1);

return 0;}

Output
Hello World
Above program will evaluate (i<1) as false since i = 2. But still, as it is a do-while loop
the body will be executed once.
Loop Control Statements
Loop control statements in C programming are used to change execution from its normal
sequence.

Name Description

the break statement is used to terminate the switch and loop statement. It
break
transfers the execution to the statement immediately following the loop or
statement
switch.

continue continue statement skips the remainder body and immediately resets its
 Name Description

statement condition before reiterating it.

goto
goto statement transfers the control to the labeled statement.
statement

Infinite Loop
An infinite loop is executed when the test expression never becomes false and the body
of the loop is executed repeatedly. A program is stuck in an Infinite loop when the
condition is always true. Mostly this is an error that can be resolved by using Loop
Control statements.
Using for loop:
 C

// C program to demonstrate infinite

// loops using for loop
#include <stdio.h>

// Driver code
int main ()
{
int i;

// This is an infinite for loop

// as the condition expression
// is blank
for ( ; ; )
{
printf("This loop will run forever.\n");
}

return 0;
}

Output
This loop will run forever.
This loop will run forever.
This loop will run forever.
...

Using While loop:

// C program to demonstrate
// infinite loop using while
// loop
#include <stdio.h>

// Driver code
int main()
{
 while (1)
printf("This loop will run forever.\n");
return 0;
}

Output
This loop will run forever.
This loop will run forever.
This loop will run forever.
...
Using the do-while loop:
 C

// C program to demonstrate
// infinite loop using do-while
// loop
#include <stdio.h>

// Driver code
int main()
{
do
{
printf("This loop will run forever.\n");
} while (1);

return 0;
}

Output
This loop will run forever.
This loop will run forever.
This loop will run forever.
...

C Arrays




Array in C is one of the most used data structures in C programming. It is a simple and fast way of storing multiple
values under a single name. In this article, we will study the different aspects of array in C language such as array
declaration, definition, initialization, types of arrays, array syntax, advantages and disadvantages, and many more.
What is Array in C?
An array in C is a fixed-size collection of similar data items stored in contiguous memory locations. It can be used to
store the collection of primitive data types such as int, char, float, etc., and also derived and user-defined data types
such as pointers, structures, etc.

C Array Declaration
In C, we have to declare the array like any other variable before using it. We can declare an array by specifying its
name, the type of its elements, and the size of its dimensions. When we declare an array in C, the compiler allocates the
memory block of the specified size to the array name.
Syntax of Array Declaration
data_type array_name [size];
or
data_type array_name [size1] [size2]...[sizeN];
where N is the number of dimensions.

The C arrays are static in nature, i.e., they are allocated memory at the compile time.

Example of Array Declaration

// C Program to illustrate the array declaration

#include <stdio.h>

int main()
{

// declaring array of integers

int arr_int[5];
// declaring array of characters
char arr_char[5];

return 0;
}

C Array Initialization
Initialization in C is the process to assign some initial value to the variable. When the array is declared or allocated
memory, the elements of the array contain some garbage value. So, we need to initialize the array to some meaningful
value. There are multiple ways in which we can initialize an array in C.

1. Array Initialization with Declaration

In this method, we initialize the array along with its declaration. We use an initializer list to initialize multiple elements of
the array. An initializer list is the list of values enclosed within braces { } separated b a comma.
data_type array_name [size] = {value1, value2, ... valueN};

2. Array Initialization with Declaration without Size

If we initialize an array using an initializer list, we can skip declaring the size of the array as the compiler can
automatically deduce the size of the array in these cases. The size of the array in these cases is equal to the number of
elements present in the initializer list as the compiler can automatically deduce the size of the array.

data_type array_name[] = {1,2,3,4,5};

The size of the above arrays is 5 which is automatically deduced by the compiler.
3. Array Initialization after Declaration (Using Loops)
We initialize the array after the declaration by assigning the initial value to each element individually. We can use for
loop, while loop, or do-while loop to assign the value to each element of the array.
for (int i = 0; i < N; i++) {
array_name[i] = valuei;
}

Example of Array Initialization in C

// C Program to demonstrate array initialization

#include <stdio.h>

int main()
{

// array initialization using initialier list

int arr[5] = { 10, 20, 30, 40, 50 };

// array initialization using initializer list without

// specifying size
int arr1[] = { 1, 2, 3, 4, 5 };

// array initialization using for loop

float arr2[5];
for (int i = 0; i < 5; i++)
{
arr2[i] = (float)i * 2.1;
}
return 0;
}

Output
Access Array Elements
We can access any element of an array in C using the array subscript operator [ ] and the index value i of the element.
array_name [index];
One thing to note is that the indexing in the array always starts with 0, i.e., the first element is at index 0 and the last
element is at N – 1 where N is the number of elements in the array.

Example of Accessing Array Elements using Array Subscript Operator

// C Program to illustrate element access using array
// subscript
#include <stdio.h>
int main()
{
// array declaration and initialization
int arr[5] = { 15, 25, 35, 45, 55 };

// accessing element at index 2 i.e 3rd element

printf("Element at arr[2]: %d\n", arr[2]);

// accessing element at index 4 i.e last element

printf("Element at arr[4]: %d\n", arr[4]);

// accessing element at index 0 i.e first element

printf("Element at arr[0]: %d", arr[0]);

return 0;
}

Output
Element at arr[2]: 35
Element at arr[4]: 55
Element at arr[0]: 15
 Update Array Element
We can update the value of an element at the given index i in a similar way to accessing an element by using the array
subscript operator [ ] and assignment operator =.
array_name[i] = new_value;

C Array Traversal
Traversal is the process in which we visit every element of the data structure. For C array traversal, we use loops to
iterate through each element of the array.
Array Traversal using for Loop
for (int i = 0; i < N; i++) {
array_name[i];
}

How to use Array in C?

The following program demonstrates how to use an array in the C programming language:
C
// C Program to demonstrate the use of array
#include <stdio.h>

int main()
{
// array declaration and initialization
int arr[5] = { 10, 20, 30, 40, 50 };

// modifying element at index 2

arr[2] = 100;

// traversing array using for loop

printf("Elements in Array: ");
for (int i = 0; i < 5; i++) {
printf("%d ", arr[i]);
}

return 0;
}

Output
Elements in Array: 10 20 100 40 50

Types of Array in C
There are two types of arrays based on the number of dimensions it has. They are as follows:
1. One Dimensional Arrays (1D Array)
2. Multidimensional Arrays
1. One Dimensional Array in C
The One-dimensional arrays, also known as 1-D arrays in C are those arrays that have only one dimension.
Syntax of 1D Array in C
array_name [size];

Example of 1D Array in C
C
// C Program to illustrate the use of 1D array
#include <stdio.h>

int main()
{
 // 1d array declaration
int arr[5];

// 1d array initialization using for loop

for (int i = 0; i < 5; i++) {
arr[i] = i * i - 2 * i + 1;
}

printf("Elements of Array: ");

// printing 1d array by traversing using for loop
for (int i = 0; i < 5; i++) {
printf("%d ", arr[i]);
}

return 0;
}

Output
Elements of Array: 1 0 1 4 9

Array of Characters (Strings)

In C, we store the words, i.e., a sequence of characters in the form of an array of characters terminated by a NULL
character. These are called strings in C language.
C
// C Program to illustrate strings
#include <stdio.h>

int main()
{

// creating array of character

char arr[6] = { 'G', 'e', 'e', 'k', 's', '\0' };

// printing string
int i = 0;
while (arr[i]) {
printf("%c", arr[i++]);
}
return 0;
}

Output
Geeks

2. Multidimensional Array in C
Multi-dimensional Arrays in C are those arrays that have more than one dimension. Some of the popular
multidimensional arrays are 2D arrays and 3D arrays. We can declare arrays with more dimensions than 3d arrays but
they are avoided as they get very complex and occupy a large amount of space.

A. Two-Dimensional Array in C
A Two-Dimensional array or 2D array in C is an array that has exactly two dimensions. They can be visualized in the
form of rows and columns organized in a two-dimensional plane.

Syntax of 2D Array in C
array_name[size1] [size2];
Here,
 size1: Size of the first dimension.
 size2: Size of the second dimension.

Example of 2D Array in C
C
// C Program to illustrate 2d array
#include <stdio.h>
int main()
{

// declaring and initializing 2d array

int arr[2][3] = { 10, 20, 30, 40, 50, 60 };

printf("2D Array:\n");
// printing 2d array
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ",arr[i][j]);
}
printf("\n");
}

return 0;
}

Output
2D Array:
10 20 30
40 50 60
B. Three-Dimensional Array in C
Another popular form of a multi-dimensional array is Three Dimensional Array or 3D Array. A 3D array has exactly three
dimensions. It can be visualized as a collection of 2D arrays stacked on top of each other to create the third dimension.
Syntax of 3D Array in C
array_name [size1] [size2] [size3];

Example of 3D Array
C
// C Program to illustrate the 3d array
#include <stdio.h>

int main()
{

// 3D array declaration
int arr[2][2][2] = { 10, 20, 30, 40, 50, 60 };

// printing elements
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
printf("%d ", arr[i][j][k]);
}
printf("\n");
}
printf("\n \n");
}
return 0;
}

Output
10 20
30 40

50 60
0 0
To know more about Multidimensional Array in C, refer to this article – Multidimensional Arrays in C
Relationship between Arrays and Pointers
Arrays and Pointers are closely related to each other such that we can use pointers to perform all the possible
operations of the array. The array name is a constant pointer to the first element of the array and the array decays to
the pointers when passed to the function.
C
// C Program to demonstrate the relation between arrays and
// pointers
#include <stdio.h>
int main()
{
int arr[5] = { 10, 20, 30, 40, 50 };
int* ptr = &arr[0];

// comparing address of first element and address stored

// inside array name
printf("Address Stored in Array name: %p\nAddress of "
"1st Array Element: %p\n",
arr, &arr[0]);

// printing array elements using pointers

printf("Array elements using pointer: ");
for (int i = 0; i < 5; i++) {
printf("%d ", *ptr++);
}
return 0;
}

Output
Address Stored in Array name: 0x7ffcab67d8e0
Address of 1st Array Element: 0x7ffcab67d8e0
Array elements using pointer: 10 20 30 40 50
To know more about the relationship between an array and a pointer, refer to this article – Pointer to an Arrays | Array
Pointer
Passing an Array to a Function in C
An array is always passed as pointers to a function in C. Whenever we try to pass an array to a function, it decays to the
pointer and then passed as a pointer to the first element of an array.
We can verify this using the following C Program:
C
// C Program to pass an array to a function
#include <stdio.h>
void printArray(int arr[])
{
printf("Size of Array in Functions: %d\n", sizeof(arr));
printf("Array Elements: ");
for (int i = 0; i < 5; i++) {
printf("%d ",arr[i]);
}
}
// driver code
int main()
{

int arr[5] = { 10, 20, 30, 40, 50 };

printf("Size of Array in main(): %d\n", sizeof(arr));

printArray(arr);
return 0;
}

Output
Size of Array in main(): 20
Size of Array in Functions: 8
Array Elements: 10 20 30 40 50
Return an Array from a Function in C
In C, we can only return a single value from a function. To return multiple values or elements, we have to use pointers.
We can return an array from a function using a pointer to the first element of that array.
C
// C Program to return array from a function
#include <stdio.h>
// function
int* func()
{
static int arr[5] = { 1, 2, 3, 4, 5 };
return arr;
}
// driver code
int main()
{
int* ptr = func();
printf("Array Elements: ");
for (int i = 0; i < 5; i++) {
printf("%d ", *ptr++);
}
return 0;
}

Output
Array Elements: 1 2 3 4 5
Note: You may have noticed that we declared static array using static keyword. This is due to the fact that when a
function returns a value, all the local variables and other entities declared inside that function are deleted. So, if we
create a local array instead of static, we will get segmentation fault while trying to access the array in the main function.

Properties of Arrays in C
It is very important to understand the properties of the C array so that we can avoid bugs while using it. The following
are the main properties of an array in C:
1. Fixed Size
The array in C is a fixed-size collection of elements. The size of the array must be known at the compile time and it
cannot be changed once it is declared.
2. Homogeneous Collection
We can only store one type of element in an array. There is no restriction on the number of elements but the type of all
of these elements must be the same.
3. Indexing in Array
The array index always starts with 0 in C language. It means that the index of the first element of the array will be 0 and
the last element will be N – 1.
4. Dimensions of an Array
A dimension of an array is the number of indexes required to refer to an element in the array. It is the number of
directions in which you can grow the array size.
5. Contiguous Storage
All the elements in the array are stored continuously one after another in the memory. It is one of the defining
properties of the array in C which is also the reason why random access is possible in the array.
6. Random Access
The array in C provides random access to its element i.e we can get to a random element at any index of the array in
constant time complexity just by using its index number.
7. No Index Out of Bounds Checking
There is no index out-of-bounds checking in C/C++, for example, the following program compiles fine but may produce
unexpected output when run.
C
// This C program compiles fine
// as index out of bound
// is not checked in C.
#include <stdio.h>
int main()
{
int arr[2];
printf("%d ", arr[3]);
printf("%d ", arr[-2]);
return 0;
}

Output
0 0
In C, it is not a compiler error to initialize an array with more elements than the specified size. For example, the below
program compiles fine and shows just a Warning.
C
#include <stdio.h>
int main()
{

// Array declaration by initializing it

// with more elements than specified size.
int arr[2] = { 10, 20, 30, 40, 50 };

return 0;
}
Output
Warnings:
prog.c: In function 'main':
prog.c:7:25: warning: excess elements in array initializer
int arr[2] = { 10, 20, 30, 40, 50 };
^
prog.c:7:25: note: (near initialization for 'arr')
prog.c:7:29: warning: excess elements in array initializer
int arr[2] = { 10, 20, 30, 40, 50 };
^
prog.c:7:29: note: (near initialization for 'arr')
prog.c:7:33: warning: excess elements in array initializer
int arr[2] = { 10, 20, 30, 40, 50 };
^
prog.c:7:33: note: (near initialization for 'arr')
Examples of Array in C
Example 1: C Program to perform array input and output.
In this program, we will use scanf() and print() function to take input and print output for the array.
C
// C Program to perform input and output on array
#include <stdio.h>

int main()
{

// declaring an integer array

int arr[5];

// taking input to array elements one by one

for (int i = 0; i < 5; i++) {
scanf("%d", &arr[i]);
}

// printing array elements

printf("Array Elements: ");
for (int i = 0; i < 5; i++) {
printf("%d ", arr[i]);
}
return 0;
}

Output
Array Elements: 15775231 0 0 0 4195776

Input
5 7 9 1 4
Output
Array Elements: 5 7 9 1 4
Example 2: C Program to print the average of the given list of numbers
In this program, we will store the numbers in an array and traverse it to calculate the average of the number stored.
C
// C Program to the average to two numbers
#include <stdio.h>

// function to calculate average of the function

float getAverage(float* arr, int size)
{

int sum = 0;
// calculating cumulative sum of all the array elements
for (int i = 0; i < size; i++) {
sum += arr[i];
}

// returning average
return sum / size;
}

// driver code
int main()
{

// declaring and initializing array

float arr[5] = { 10, 20, 30, 40, 50 };
// size of array using sizeof operator
int n = sizeof(arr) / sizeof(float);
 // printing array elements
printf("Array Elements: ");
for (int i = 0; i < n; i++) {
printf("%.0f ", arr[i]);
}

// calling getAverage function and printing average

printf("\nAverage: %.2f", getAverage(arr, n));
return 0;
}

Output
Array Elements: 10 20 30 40 50
Average: 30.00
Example 3: C Program to find the largest number in the array.
C
// C Program to find the largest number in the array.
#include <stdio.h>

// function to return max value

int getMax(int* arr, int size)
{
int max = arr[0];
for (int i = 1; i < size; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
return max;
}
// Driver code
int main()
{
int arr[10]
= { 135, 165, 1, 16, 511, 65, 654, 654, 169, 4 };
printf("Largest Number in the Array: %d",
getMax(arr, 10));

return 0;
}

Output
Largest Number in the Array: 654
Advantages of Array in C
The following are the main advantages of an array:
1. Random and fast access of elements using the array index.
2. Use of fewer lines of code as it creates a single array of multiple elements.
3. Traversal through the array becomes easy using a single loop.
4. Sorting becomes easy as it can be accomplished by writing fewer lines of code.
Disadvantages of Array in C
1. Allows a fixed number of elements to be entered which is decided at the time of declaration. Unlike a linked list, an
array in C is not dynamic.
2. Insertion and deletion of elements can be costly since the elements are needed to be rearranged after insertion and
deletion.
Conclusion
The array is one of the most used and important data structures in C. It is one of the core concepts of C language that is
used in every other program. Though it is important to know about its limitation so that we can take advantage of its
functionality.
FAQs on C Array
1. Define Array in C.
An array is a fixed-size homogeneous collection of elements that are stored in a contiguous memory location.
2. How to declare an array in C?
We can declare array in C using the following syntax:
datatype array_name [size];
3. How do you initialize an array in C?
We can initialize an array using two methods:
 Using Initializer list
 Using Loops
Using Initializer List
We can use an initializer list to initialize the array with the declaration using the following syntax:
datatype array_name [size] = {value1, value2,...valueN};
Using Loops
We can initialize an Array using Loops in C after the array declaration:
for (int i = 0; i < N; i++) {
array_name[i] = valuei;
}
4. Why do we need Arrays?
We can use normal variables (v1, v2, v3, ..) when we have a small number of objects, but if we want to store a large
number of instances, it becomes difficult to manage them with normal variables. The idea of an array is to represent
many instances in one variable.
5. How can we determine the size of the C array?
We can determine the size of the Array using sizeof Operator in C. We first get the size of the whole array and divide it
by the size of each element type.
6. What is the difference between Arrays and Pointers?
The following table list the differences between an array and a pointer:

Pointer Array

A pointer is a derived data type that

An array is a homogeneous collection of
can store the address of other
items of any type such as int, char, etc.
variables.

Pointers are allocated at run time. Arrays are allocated at compile time.

An array is a collection of variables of the

The pointer is a single variable.
same type.

Dynamic in Nature Static in Nature.