C Arrays

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., as well as derived and user-defined data types such as pointers, structures, etc.

Creating an Array in C

The whole process of creating an array in C language can be divided in to 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. When we declare an array in C, the compiler allocates the memory block of the specified size to the array name.

Syntax:

data_type array_name[size];

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];

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. Which can be done using initializer list, which is the list of values enclosed within braces { } separated by a comma.

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 partially initialize the array by skiping some values during initialisation. Also 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.

Syntax for partial Initialisation of an Array

//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 element which means that we can access any element of the array by providing the position of the element, called the index. 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.

Syntax:

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;
}

2 4 8 12 16 

Size of Array

The size of the array refers to the number of elements that can be stored in the array. 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;
}

• 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.

Multidimensional Array in C

In the above, we only discussed one-dimension array. Multi-dimensional arrays in C are arrays that grow in multiple directions or dimensions. A one-dimensional array grows linearly, like parallel to the X-axis, while in a multi-dimensional array, such as a two-dimensional array, the elements can grow along both the X and Y axes.

return_type array_name[size1]
            [size2] .. [sizen];

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.

Example:

#include <stdio.h>

int main() {
    
    // 2D array declaration
    int arr[4][4];
    
    // Initialize 2d array
    for(int i = 0; i<4; i++){
        int val = 1;
        for(int j = 0; j < 4; j++){
            arr[i][j] = val++; 
        }
    }
    
    // Print 2d array
    for(int i = 0; i<4; i++){
        for(int j = 0; j < 4; j++){
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
    return 0;
}

1 2 3 4 
1 2 3 4 
1 2 3 4 
1 2 3 4 

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.

Example:

#include <stdio.h>

int main() {
    
    // 3D array declaration (3 layers, 3 rows, 3 columns)
    int arr[3][3][3];
    
    // Filling the 3D array
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            int val = 1;
            for(int k = 0; k < 3; k++) {
                arr[i][j][k] = val++; 
            }
        }
    }
    
    // Printing the 3D array
    for(int i = 0; i < 3; i++) {
        printf("Layer %d:\n", i+1);
        for(int j = 0; j < 3; j++) {
            for(int k = 0; k < 3; k++) {
                printf("%d ", arr[i][j][k]);
            }
            printf("\n");
        }
        printf("\n");
    }
    return 0;
}

Layer 1:
1 2 3 
1 2 3 
1 2 3 

Layer 2:
1 2 3 
1 2 3 
1 2 3 

Layer 3:
1 2 3 
1 2 3 
1 2 3 

To know more about Multidimensional Array in C, refer to this article - Multidimensional Arrays in C

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.

#include <stdio.h>

int main() {

    int arr[5] = { 10, 20, 30, 40, 50 };
    int* ptr = &arr[0];
    
    // Address store inside 
    // name
    printf("%p\n", arr);
    
    // Print the address which
    // is pointed by pointer ptr
    printf("%p\n", ptr);
    return 0;
}

0x7ffde73e54b0
0x7ffde73e54b0

To know more about the relationship between an array and a pointer, refer to this article - Pointer to an Arrays | Array Pointer.

Passing array to Function

In C, arrays are passed to functions using pointers, as the array name decays to a pointer to the first element. There are three common methods for passing array to functions in C:

• Unsized array notation, where the array is passed as a pointer without specifying its size.
• Sized array notation, where the size is included in the declaration for clarity, but it’s still passed as a pointer.
• Pointer notation, where the array is explicitly passed as a pointer, often along with its size.

Example:

#include <stdio.h>

// Functions that take array as argument
void sized_array_notation(int arr[5]) {}

void unsized_array_notation(int arr[]) {}

void pointer_notation(int* arr) {}

int main() {
    int arr[] = {2, 4, 8, 12, 16};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    // Passing array
    sized_array_notation(arr);
    unsized_array_notation(arr);
    pointer_notation(arr);
    return 0;
}

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. C 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.

kartik

Follow

Improve

Article Tags :

• C Language
• C-Arrays