C Arrays

-

 

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

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

1d array in c
 
Example of 1D Array in 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 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.
2d array in c
 
Example of 2D Array in 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];

3d array in c
 
Example of 3D Array
// 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 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: 0x7ffce72c2660
Address of 1st Array Element: 0x7ffce72c2660
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 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 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.  
// 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
211343841 4195777 


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.
#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;
}
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 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;
}
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 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 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: 65
An array in C is a fixed-size homogeneous collection of elements stored at a contiguous memory location. It is a derived data type in C that can store elements of different data types such as int, char, struct, etc. It is one of the most popular data types widely used by programmers to solve different problems not only in C but also in other languages.
The properties of the arrays depend on the programming language. In this article, we will study the different properties of Array in the C programming language.
  1. Fixed Size Collection
  2. Homogeneous Elements
  3. Indexing in Array
  4. Dimensions of Array
  5. Contiguous Storage
  6. Random Access
  7. Array name relation with pointer
  8. Bound Checking
  9. Array Decay
C Array Properties
1. Fixed Size of an Array
In C, the size of an array is fixed after its declaration. It should be known at the compile time and it cannot be modified later in the program. The below example demonstrates the fixed-size property of the array.
Example:
C
// C Program to Illustrate the Fixed Size Properties of the
// Array
#include <stdio.h>
 
int main()
{
 
    // creating a new array of size 5
    int array[5] = { 1, 2, 3, 4, 5 };
 
    printf("Size of Array Before: %d\n",
           sizeof(array) / sizeof(int));
 
    // trying to increase the size of the array
    array[6];
    // not checking the size
    printf("Size of Array After: %d",
           sizeof(array) / sizeof(int));
 
    return 0;
}
Output
Size of Array Before: 5
Size of Array After: 5
2. Homogeneous Collection
An array in C cannot have elements of different data types. All the elements are of the same type.
Example:
C
// C program to Demonstrate the Homogeneous Property of the
// C Array
#include <stdio.h>
 
int main()
{
 
    // declaring integer array
    int arr[3] = { 1, 2 };
 
    // trying to store string in the third element
    arr[2] = "Geeks";
 
  // printing elements
    printf("Array[1]: %d\n", arr[0]);
    printf("Array[2]: %d\n", arr[1]);
    printf("Array[3]: %s", arr[2]);
 
    return 0;
}
Output
main.c: In function ‘main’:
main.c:12:16: warning: assignment to ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
   12 |         arr[2] = "Geeks";
      |                ^
main.c:17:28: warning: format ‘%s’ expects argument of type ‘char *’, but argument 2 has type ‘int’ [-Wformat=]
   17 |         printf("Array[3]: %s", arr[2]);
      |                           ~^   ~~~~~~
      |                            |      |
      |                            char * int
      |                           %d
Array[1]: 1
Array[2]: 2
3. Indexing in an Array
Indexing of elements in an Array in C starts with 0 instead of 1. It means that the index of the first element will be 0 and the last element will be (size – 1) where size is the size of the array.
indexing of array elements in c
Indexing of Elements in C Array
Example:
C
// C Program to Illustrate Array Indexing in C
#include <stdio.h>
 
int main()
{
 
    // creating integer array with 2 elements
    int arr[2] = { 10, 20 };
 
    // printing element at index 1
    printf("Array[1]: %d\n", arr[1]);
 
    // printing element at index 0
    printf("Array[0]: %d", arr[0]);
   
    return 0;
}
Output
Array[1]: 20
Array[0]: 10
As we see in the above example, at index 1, the second element is present while at index 0, the first element is present.
4. Dimensions of the Array
An array in C can be a single dimensional like a 1-D array or multidimensional like a 2-D array, 3-D array, and so on. It can have any number of dimensions. The number of elements in a multidimensional array is the product of the size of all the dimensions.
arrays of different dimensions
Arrays of Different Dimensions
Example:
C
// C Program to create multidimensional array
#include <stdio.h>
 
int main()
{
 
    // creating 2d array
    int arr2d[2][2] = { 1, 2, 3, 4 };
 
    // creating 3d array
    int arr3d[2][2][2] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 
    printf("2D Array: ");
    // printing 2d array
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            printf("%d ", arr2d[i][j]);
        }
    }
 
    printf("\n3D Array: ");
    // printing 3d array
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            for (int k = 0; k < 2; k++) {
                printf("%d ", arr3d[i][j][k]);
            }
        }
    }
 
    return 0;
}
Output
2D Array: 1 2 3 4 
3D Array: 1 2 3 4 5 6 7 8 
5. Contiguous Storage
All the elements in an array are stored at contiguous or consecutive memory locations. We can easily imagine this concept in the case of a 1-D array but multidimensional arrays are also stored contiguously. It is possible by storing them in row-major or column-major order where the row after row or column after the column is stored in the memory. We can verify this property by using pointers.
Example:
C++
// C Program to Verify the Contiguous Storage of Elements in
// an Array
#include <stdio.h>
 
int main()
{
 
    // creating an array of 5 elements
    int arr[5] = { 1, 2, 3, 4, 5 };
 
    // defining pointers to 2 consecutive elements
    int* ptr1 = &arr[1];
    int* ptr2 = &arr[2];
 
    // printing the address of arr[1] and arr[2]
    printf("Address of arr[1] : %p\n", ptr1);
    printf("Address of arr[2] : %p", ptr2);
 
    return 0;
}
Output
Address of arr[1] : 0x7fffb8cc1ef4
Address of arr[2] : 0x7fffb8cc1ef8
In the above example, the difference between the addresses of arr[1] and arr[2] is 4 bytes which is the memory required to store a single integer. So, at memory addresses 0x7ffebc02e054 to 0x7ffebc02e057, arr[1] is stored and in the next 4 bytes, arr[2] is stored. The same is true for all the elements.
6. Random Access to the Elements
It is one of the defining properties of an Array in C. It means that we can randomly access any element in the array without touching any other element using its index. This property is the result of Contiguous Storage as a compiler deduces the address of the element at the given index by using the address of the first element and the index number.
Address of ith = Address of 1st Element + (Index * Size of Each Element)
array elements with memory addresses
Array in C
We can verify this by using Pointer Arithmetic.
Example:
C
// C Program to check the random access property of the
// array
#include <stdio.h>
 
int main()
{
 
    // creating an array of 5 elements
    int arr[5] = { 1, 2, 3, 4, 5 };
 
    // address of first element
    int* ptr = &arr[0];
 
    // printing arr[3]
    printf("Array[3]: %d\n", arr[3]);
 
    // printing element at index 3 using ptr
    printf("Array[3] using pointer to first element = %d",
           *(ptr + 3));
 
    return 0;
}
Output
Array[3]: 4
Array[3] using pointer to first element = 4
Note: We have not multiplied the size of each element in the code as the compiler deduce and multiply it automatically by itself whenever we perform pointer arithmetic.
7. Relationship between Array and Pointers
Arrays are closely related to pointers in the sense that we can do almost all the operations possible on an array using pointers. The array’s name itself is the pointer to its first element.
Example:
C
// C Program to Illustrate the Relationship Between Array
// and Pointers
#include <stdio.h>
 
int main()
{
 
    // creating an array with 3 elements
    int arr[3] = { 1, 2, 3 };
 
    int* ptr = &arr[0];
 
    // Pointer to first element
    printf("Pointer to First Element: %p\n", ptr);
 
    // Array name as pointer
    printf("Arran Name: %p", arr);
 
    return 0;
}
Output
Pointer to First Element: 0x7ffec5059660
Arran Name: 0x7ffec5059660
The relationship between pointer and array is very deep and we can study more about it in other articles such as – Pointer to an Array | Array Pointer
8. Bound Checking
Bound checking is the process in which it is checked whether the referenced element is present within the declared range of the Array. In C language, array bound checking is not performed so we can refer to the elements outside the declared range of the array leading to unexpected errors.
Example:
C
// C Program to Illustrate the Out of Bound access in arrays
#include <stdio.h>
 
int main()
{
 
    // creating new array with 3 elements
    int arr[3] = { 1, 2, 3 };
 
    // trying to access out of bound element
    printf("Some Garbage Value: %d", arr[5]);
 
    return 0;
}
Output
Some Garbage Value: 0
As seen in the above example, there is no error shown by the compiler while accessing memory that is out of array bounds.
9. Array Decay
Array decay is the process in which an array in C loses its dimension in certain conditions and decays into pointers. After this, we cannot determine the size of the array using sizeof() operator. It happens when an array is passed as a pointer.
Example:
C
// C Program to Demonstrate the Array Decay
#include <stdio.h>
 
// function
void func(int* arr)
{
    printf("Sizeof Value in Function: %d", sizeof(arr));
}
 
int main()
{
 
    // creating array with 3 elements
    char arr[3];
 
    printf("Sizeof Value in Main: %d\n", sizeof(arr));
 
    // passing array
    func(arr);
 
    return 0;
}
Output
Sizeof Value in Main: 3
Sizeof Value in Function: 8
The size of the array in the main() is 3 bytes which is the actual size of the array but when we check the size of the array in func(), the size comes out to be 8 bytes which instead of being the size of the array, it is the size of the pointer to the first element of the array.
The Length of an array in C refers to the number of elements in the array. It must be specified at the time of declaration. It is also known as the size of an array that is used to determine the memory required to store all of its elements. In C Programming language, we don’t have any pre-defined function to find the length of the array but we can manually determine it by using different methods mentioned below:
  1. Using sizeof() Operator
  2. Using Pointer Arithmetic
  3. Using Loop
1. Using sizeof() Operator
The sizeof operator is a compile-time unary operator that calculates the size of the variables and datatypes. It returns an integer value that represents the size of the expression or a variable in bytes. The sizeof operator is primarily used for dynamic memory allocation but it can also be used to find the length of an array.
The trick is to first find the size of the whole array in bytes and the size of a single element using the sizeof operator and then divide the size of the whole array by the size of a single element so that we can get the number of elements in the array.
Syntax:
data_type size = sizeof(Array_name) / sizeof(Array_name[index]);
In the above syntax,
  • data_type: It is the type of variable in which we want to store the length of the array.(like int, size_t, etc.).
  • Array_name: It is the name of the array you want to find the size of.
  • sizeof(Array_name): It is an operator that returns the size of the entire array in bytes.
  • sizeof(Array_name[index]): It returns the size of a single element in the array in bytes.
  • index: It is the index of any element in the array.
Example:
// C Program to calculate size of an array using sizeof()
// operator
#include <stdio.h>
 
int main()
{
 
    int Arr[] = { 1, 2, 3, 4, 5 };
   
    // variable to store size of Arr
    int length = sizeof(Arr) / sizeof(Arr[0]);
 
    printf("The length of the array is: %d\n", length);
 
    return 0;
}
Output
The length of the array is: 5
Time Complexity: O(1) as only constant time operations has been done.
Space Complexity: O(1) as no extra space has been used. 
2. Using Pointer Arithmetic
We can also calculate the length of an array in C using pointer arithmetic. This solution of using a pointer is just a hack that is used to find the number of elements in an array.
Syntax:
 data_type length = *(&arr + 1) - arr;
In the above syntax:
  • &arr: Pointer to an array of elements.
  • (&arr + 1): Address of memory ahead of the array as pointer type is a pointer to an array of integers.
  • *(&arr + 1) – arr: Inclusive difference between the start and the end of the array
Example:
// C Program to calculate size of an array using pointer arithmetic
#include <stdio.h>
 
int main()
{
 
    int Arr[] = { 1, 2, 3, 4, 5, 6 };
    // variable to store the size of Arr
    int length = *(&Arr + 1) - Arr;
 
    printf( "Number of elements in Arr[] is: %d", length);
    return 0;
}
Output
Number of elements in Arr[] is: 6
3. Using Loop
The loop method is used to calculate the length of an array in C. It iterates through all the elements of an array and increments the count.
Example:
// C Program to calculate size of an array using loop
#include <stdio.h>
  
int arr_length(int arr[])
{
    int i;
    int count = 0;
    for(i=0; arr[i]!='\0'; i++)
    {
        count++;
    }
    return count;
}
  
int main()
{
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int n;
  
    n = arr_length(arr);
    printf("Length of Array is: %d", n);
  
    return 0;
}
 
// This code is contributed by Susobhan Akhuli
Output
Length of Array is: 10
Time Complexity: O(n) where n is the number of elements in the array.
Space Complexity: O(1) as no extra space has been used.
Note: Please note that these methods only works when the array is declared in the same scope. These methods will fail if we try them on an array which is passed as a pointer. This happens due to Array Decay.
The iterative methods of finding the length of the strings (array of characters) also cannot be applied to the array of other types as there is no end indicator in these array types in contrast to the ‘\0’ NULL character marking the end of the string.


Comments

Post a Comment