Arrays in C Programming: Operations on Arrays

An Array in C programming language is a powerful data structure that allows

users to store and manipulate a collection of elements, all of the same data
type in a single variable. Simply, it is a collection of elements of the same data
type.
Arrays are the derived data type in C that can store values of both
- fundamental data types like int, and char; and derived data
types like pointers, and structure. The values get stored at contagious memory
locations that can be accessed with their index number.
Syntax
dataType arrayName[arraySize];
eg: int a[5];
Properties of an Array in C
 Declaration: Arrays in C are declared by specifying the data type of the
elements and the number of elements in the array.
 Indexing: Elements in an array are accessed using an index. The index of
the first element in an array is always 0.
 Memory allocation: Arrays in C are allocated contiguous memory
locations at the time of declaration. The amount of memory allocated for
an array is equal to the product of the number of elements and the size of
each element.
 Initialization: Arrays in C can be initialized at the time of declaration or
later.
 Size: The size of an array is the number of elements in the array. The size
of an array can be calculated using the sizeof() operator.
 Manipulation: Arrays in C can be manipulated using loops, functions,
and other programming constructs.
Types of Arrays in C
There are two types of array in C, which are:
1. Single-dimensional array: It is a collection of elements of the same
data type that are stored in a contiguous block of memory.
2. Multi-dimensional array: It is an array that contains one or more
arrays as its elements. We will see this in the How to initialize an
array in C?
There are various ways to do this:
o Initialize at the time of declaration using “{}”.
int a[5] = {1, 2, 3, 4, 5};
o Initialize an array without specifying its size at declaration time.
int a[] = {1, 2, 3, 4, 5};
Though we haven't specified the size, the compiler understands the size as 5 due
to the initialization of 5 elements.
Initialization by using the index of an element
int marks[5];
marks[0]=80; //the index of an array starts with 0.
marks[1]=60;
marks[2]=70;
marks[3]=85;
marks[4]=75;
Accessing Elements of an Array in C
To access the array elements, use the index number of the required element. The
array index starts with 0. The index of the last element is n-1.

#include <stdio.h>
int main() {
int a[] = {25, 50, 75, 100};
printf("%d\n", a[0]);
printf("%d\n", a[1]);
printf("%d\n", a[2]);
printf("%d\n", a[3]);
printf("%d\n", a[4]);
return 0;
}
Output:
25
50
75
100
45

Changing the Elements of an array in C

To change the value of a specific element, refer to the index number

#include <stdio.h>
int main()
{
int a[] = {25, 50, 75, 100, 45};
a[3] = 60;
printf("%d\n", a[3]);
return 0;
}

Output: 60
Traversing an Array in C
To traverse an array, for loop is used.

#include <stdio.h>
int main(){
int i=0;
int marks[5];//declaration of array
marks[0]=90;//initialization of array
marks[1]=80;
marks[2]=70;
marks[3]=95;
marks[4]=85;

//traversal of array
for(i=0;i<5;i++){
printf("%d \n",marks[i]);
}//end of for loop
return 0;
}

Output:
90
80
70
95
85

Input and Output Array Elements in C

We can use the scanf() function to take inputs of an array from the user.

// Program to take values of the array from the user and print the array

#include <stdio.h>
int main()
{
int a[5];
printf("Enter the values of an integer array:\n ");

// taking input and storing it in an array

for(int i = 0; i < 5; ++i) {
scanf("%d", &a[i]);
}
 printf("Displaying integers: ");
// printing elements of an array
for(int i = 0; i < 5; ++i) {
printf("%d\n", a[i]);
}
return 0;
}
Output:
Enter the values of an integer array:
1
2
3
4
5
Displaying integers:
1
2
3
4
5

Advantages of an Array in C
 Efficient memory usage: Arrays in C use contiguous memory
locations to store the elements, thus making it efficient to allocate and
access data.
 Easy access to elements: Elements in an array can be accessed using
their index, making it easy to retrieve specific data from the array.
 Better performance: Accessing elements in an array using an index is
faster than using other data structures like linked lists or trees. This is
because the index provides direct access to the memory location where
the element is stored.
 Flexibility: Arrays in C can be used to store different types of data,
including integers, characters, and strings.
 Easy to implement algorithms: Many algorithms in computer science
use arrays, making it easy to implement these algorithms in C.
 Compatible with other data structures: Arrays can be used in
conjunction with other data structures in C, such as stacks and queues, to
implement complex data structures and algorithms.
 Easy to pass to functions: Arrays can be easily passed as arguments
to functions in C, making it easy to manipulate large amounts of data
efficiently.
Disadvantages of an Array in C
 Fixed-size: Arrays in C have a fixed size determined at the time of
declaration. There is no dynamic increase in the size of an array.
 Memory allocation: Arrays in C are allocated in contiguous memory
blocks. If the array is very large, there may not be enough contiguous
memory available for allocation.
 No bounds checking: C does not perform any bounds checking on
arrays, so it is possible to access memory outside of the bounds of the
array. This can lead to segmentation faults or other memory-related
errors.
 Limited flexibility: Arrays in C have limited flexibility due to fixed size
and dimensions. This makes it difficult to implement certain algorithms
and data structures that require dynamic resizing and manipulation.
 Inefficient for insertion and deletion: Inserting or deleting elements
from an array in C can be inefficient, as it requires shifting all the
elements after the insertion or deletion point to make room or fill in the
gap. This can be time-consuming, especially for large arrays.
 Not suitable for non-numeric data: While arrays in C are well-suited
for storing numeric data, they aren’t ideal for storing non-numeric data,
such as strings or complex data structures. This is because C does not
provide built-in support for these types of data structures.

Array Inter Function Communication In C

To enable inter-function communication with arrays in C, you pass the array's
name (which represents the starting address) as an argument to the function,
allowing the function to access and modify the array elements directly.
Here's a breakdown:
 Passing the Array: When you pass an array to a function, you're
essentially passing a pointer to the first element of the array.
 Accessing Array Elements: Inside the function, you can access array
elements using pointer arithmetic or array indexing, just as you would in
the calling function.

Note: Inter-function communication is the process of sharing data

between calling and called functions.

#include <stdio.h>

void modifyArray(int arr[], int size) // Pass the array and its size
{
for (int i = 0; i < size; i++) {
 arr[i] *= 4; // Multiply each element by 4 // MODIFYING THE ARRAY
ELEMENTS

}
}

int main() {
int my_array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int size = sizeof(my_array) / sizeof(my_array[0]);

printf("Original array: ");

for (int i = 0; i < size; i++) {
printf("%d ", my_array[i]);
}
printf("\n");

modifyArray(my_array, size); // Call the function with the array

printf("Modified array: ");

for (int i = 0; i < size; i++) {
printf("%d ", my_array[i]); // Print the modified array
}
printf("\n");

return 0;
}

✅ Final Output:
Original array: 1 2 3 4 5 6 7 8 9 10
Modified array: 4 8 12 16 20 24 28 32 36 40

🔍 Tracing Step-by-Step
1. 🧠 Memory before main runs:
 Nothing is allocated yet.

2. 🏁 Inside main():
➤ int my_array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Index my_array[i]
0 1
1 2
2 3
3 4
Index my_array[i]
4 5
5 6
6 7
7 8
8 9
9 10
These values are stored in memory in a contiguous block.

➤ int size = sizeof(my_array) / sizeof(my_array[0]);

 sizeof(my_array) = 10 elements × 4 bytes = 40
 sizeof(my_array[0]) = 4
 So: size = 40 / 4 = 10

3. Printing "Original array":

 Output:
php
CopyEdit
Original array: 1 2 3 4 5 6 7 8 9 10

4. 🔁 Calling modifyArray(my_array, size)

You're now in this function:
c
CopyEdit
void modifyArray(int arr[], int size) {
for (int i = 0; i < size; i++) {
arr[i] *= 4;
}
}
Since arr is a pointer to my_array, modifying arr[i] modifies my_array[i]
directly.
🔧 Iteration trace inside modifyArray:
i Before arr[i] After arr[i] *= 4
01 4
12 8
23 12
34 16
45 20
56 24
67 28
78 32
i Before arr[i] After arr[i] *= 4
89 36
9 10 40
After this loop, my_array is permanently modified.

5. Printing "Modified array":

Output:
php
CopyEdit
Modified array: 4 8 12 16 20 24 28 32 36 40