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

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.

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:

int arr[5];

The above statement will create an array arr that can store 5 integer values.

Array Declaration

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

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 some value, If we skip some values during initialization, it is called partial initialization.

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

We can also skip the size of the array.

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

If we want to initialize an array with all elements set to 0.

int arr[5] = {0};

Array Initialization

Accessing

We can access any element of the array by providing the position of the element, called the index. Indexes start from 0. 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\n", arr[2]);

    // accessing element at index 4 i.e last element
    printf("%d\n", 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 an element 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:

//Driver Code Starts{
#include <stdio.h>

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

    // Update the first value
    // of the array
//Driver Code Ends }

    arr[0] = 1;
    printf("%d", arr[0]);
    return 0;
}

1

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.

for (int i = 0; i < N; i++) {
    array_name[i];
}

Example:

#include <stdio.h>

int main() {
    int arr[5] = {2, 4, 8, 12, 16};
    
    // Print each element of
    // array using loop
    for(int i = 0; i < 5; 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:

//Driver Code Starts{
#include <stdio.h>

int main() {
    int arr[5] = {2, 4, 8, 12, 16};
    
//Driver Code Ends }

    // Size of the array
    int size = sizeof(arr)/sizeof(arr[0]);
    printf("%d", size);

//Driver Code Starts{
    return 0;
}
//Driver Code Ends }

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

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:

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

//Driver Code Starts{
#include <stdio.h>

//Driver Code Ends }

// 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);

//Driver Code Starts{
    return 0;
}

//Driver Code Ends }

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:

//Driver Code Starts{
#include <stdio.h>

int main() {
    
//Driver Code Ends }

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

//Driver Code Starts{
    
    // Print 2d array
    for(int i = 0; i<4; i++){
        for(int j = 0; j < 4; j++){
            printf("%d ", arr[i][j]);
        }
        printf("
");
    }
    return 0;
}

//Driver Code Ends }

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:

//Driver Code Starts{
#include <stdio.h>

int main() {
    
//Driver Code Ends }

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

//Driver Code Starts{
    
    // Printing the 3D array
    for(int i = 0; i < 3; i++) {
        printf("Layer %d:
", i+1);
        for(int j = 0; j < 3; j++) {
            for(int k = 0; k < 3; k++) {
                printf("%d ", arr[i][j][k]);
            }
            printf("
");
        }
        printf("
");
    }
    return 0;
}

//Driver Code Ends }

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

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.

//Driver Code Starts{
#include <stdio.h>

int main() {

//Driver Code Ends }

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

//Driver Code Starts{
    return 0;
}
//Driver Code Ends }

0x7ffde73e54b0
0x7ffde73e54b0

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

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:

• 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.
• We can only store one type of element in an 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.
• All the elements in the array are stored continuously one after another in the memory.
• 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.
• There is no index out-of-bounds checking in C.

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.

kartik

Follow

Improve

Article Tags :

• C Language
• C-Arrays