Arrays in C

An array is a linear data structure that stores a fixed-size sequence of elements of the same data type in contiguous memory locations. Each element can be accessed directly using its index, which allows for efficient retrieval and modification.

#include <stdio.h> int main() {    int arr[] = {2, 4, 8, 12, 16, 18};  int n = sizeof(arr)/sizeof(arr[0]);  // Printing array elements  for (int i = 0; i < n; i++) {  printf("%d ", arr[i]);  }  return 0; } 

2 4 8 12 16 18 

The below image shows the array created in the above program.

To understand the key characteristics of arrays such as fixed size, contiguous memory allocation, and random access. Refer to this article: Properties of Arrays

Creating an Array

The whole process of creating an array can be divided into two primary sub processes i.e.

1. Array Declaration

Array declaration is the process of specifying the type, name, and size of the array. In C, we have to declare the array like any other variable before using it.

data_type array_name[size]; 

The above statements create an array with the name array_name, and it can store a specified number of elements of the same data type.

Example:

// Creates array arr to store 5 integer values. int arr[5]; 

When we declare an array in C, the compiler allocates the memory block of the specified size to the array name.

2. 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 values.

Syntax:

int arr[5] = {2, 4, 8, 12, 16}; 

The above statement creates an array arr and assigns the values {2, 4, 8, 12, 16} at the time of declaration.

We can skip mentioning the size of the array if declaration and initialisation are done at the same time. This will create an array of size n where n is the number of elements defined during array initialisation. We can also partially initialize the array. In this case, the remaining elements will be assigned the value 0 (or equivalent according to the type).

//Partial Initialisation int arr[5] = {2, 4, 8}; //Skiping the size of the array. int arr[] = {2, 4, 8, 12, 16};  //initialize an array with all elements set to 0. int arr[5] = {0}; 

Accessing Array Elements

Array in C provides random access to its elements, which means that we can access any element of the array by providing the position of the element, called the index.

Syntax:

The index values start from 0 and goes up to array_size-1. We pass the index inside square brackets [] with the name of the array.

array_name [index]; 

where, index value lies into this range - (0 ≤ index ≤ size-1).

Example:

#include <stdio.h> int main() {  // array declaration and initialization  int arr[5] = {2, 4, 8, 12, 16};  // accessing element at index 2 i.e 3rd element  printf("%d ", arr[2]);  // accessing element at index 4 i.e last element  printf("%d ", arr[4]);  // accessing element at index 0 i.e first element  printf("%d ", arr[0]);  return 0; } 

8 16 2 

Update Array Element

We can update the value of array elements at the given index i in a similar way to accessing an element by using the array square brackets [] and assignment operator (=).

array_name[i] = new_value; 

Example:

#include <stdio.h> int main() {  int arr[5] = {2, 4, 8, 12, 16};  // Update the first value  // of the array  arr[0] = 1;  printf("%d", arr[0]);  return 0; } 

1

C Array Traversal

Array Traversal is the process in which we visit every element of the array in a specific order. For C array traversal, we use loops to iterate through each element of the array.

Example:

#include <stdio.h> int main() {  int arr[5] = {2, 4, 8, 12, 16};    // Print each element of  // array using loop  printf("Printing Array Elements\n");   for(int i = 0; i < 5; i++){  printf("%d ", arr[i]);  }  printf("\n");   // Printing array element in reverse  printf("Printing Array Elements in Reverse\n");   for(int i = 4; i>=0; i--){  printf("%d ", arr[i]);  }  return 0; } 

Printing Array Elements 2 4 8 12 16 Printing Array Elements in Reverse 16 12 8 4 2 

Size of Array

The size of the array refers to the number of elements that can be stored in the array. The array does not contain the information about its size but we can extract the size using sizeof() operator.

Example:

#include <stdio.h> int main() {  int arr[5] = {2, 4, 8, 12, 16};    // Size of the array  int size = sizeof(arr)/sizeof(arr[0]);  printf("%d", size);  return 0; } 

5

The sizeof() operator returns the size in bytes. sizeof(arr) returns the total number of bytes of the array. In an array, each element is of type int, which is 4 bytes. Therefore, we can calculate the size of the array by dividing the total number of bytes by the byte size of one element.

Note: This method only works in the scope in which the array is declared. Refer to this article to know more - Length of Array in C

To know how to pass an array to a function in C, refer to this article — Arrays and Pointers

For working with tables, matrices, or grids, C allows the use of arrays with more than one dimension. To learn more, refer to this article — Multidimensional Arrays in C.

Practice Array Problems

The following problems helps you to improve your efficiency in using C array:

• Find Maximum Value in an Array
• Calculate Sum of Array Elements
• Reverse Array in C
• Insert an Element in an Array
• Delete an Element in an Array
• Array rotation
• Return an Array from a Function
• Sort an Array in Ascending Order
• Find the pair with a given sum in Array

Advantages of Array

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

1. Arrays are not dynamic they only allow a fixed number of elements to be entered which is decided at the time of declaration.
2. Insertion and deletion of elements can be costly since the elements are needed to be rearranged after insertion and deletion.