What are the limitations of array in C language?

Arrays are a kind of data structure that can store a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.

Syntax

data_type array_name[array_size];

Limitations of Arrays in C

The limitations of an array are explained below −

• Homogeneous Data: An array which is formed will be homogeneous. That is, in an integer array only integer values can be stored, while in a float array only floating values and character array can have only characters. Thus, no array can have values of two data types.

• Fixed Size: While declaring an array, passing size of an array is compulsory, and the size must be a constant. Thus, there is either shortage or wastage of memory.

• Shifting Required: Shifting is required for insertion or deletion of elements in an array.

• No Boundary Check: An array doesn’t check boundaries. In C language, we cannot check if the values entered in an array are exceeding the size of that array or not.

• Buffer Overflow Risk: Data that is entered with the subscript exceeds the array size and will be placed outside the array, generally on the top of the data or the program itself. This will lead to unpredictable results and may cause the program to hang.

Example: Demonstrating Array Limitations

This example shows how arrays have fixed size and homogeneous data type restrictions −

#include <stdio.h>

int main() {
    /* Fixed size limitation - array size must be constant */
    int array1[5]; /* Cannot dynamically change size */
    
    /* Homogeneous data limitation - all elements must be same type */
    int numbers[3] = {10, 20, 30}; /* Only integers allowed */
    
    printf("Array elements: ");
    for(int i = 0; i < 3; i++) {
        printf("%d ", numbers[i]);
    }
    printf("<br>");
    
    /* Memory wastage if not all elements are used */
    int large_array[100]; /* Declared for 100 but may use only 5 */
    large_array[0] = 1;
    large_array[1] = 2;
    /* Remaining 98 elements are unused - memory wastage */
    
    printf("Used only 2 elements out of 100 allocated<br>");
    
    return 0;
}

Array elements: 10 20 30 
Used only 2 elements out of 100 allocated

Example: Array Boundary Issue

This example demonstrates the dangerous boundary issue in C arrays −

#include <stdio.h>

int main() {
    int a[3]; /* Array of size 3 */
    int i;
    
    printf("Accessing array elements:<br>");
    
    /* Safe access within bounds */
    for(i = 0; i < 3; i++) {
        a[i] = i * 10;
        printf("a[%d] = %d<br>", i, a[i]);
    }
    
    /* WARNING: This demonstrates undefined behavior */
    /* In real programs, this can cause crashes */
    printf("\nAccessing beyond array bounds (unsafe):<br>");
    printf("Note: This may show garbage values or cause errors<br>");
    
    return 0;
}

Accessing array elements:
a[0] = 0
a[1] = 10
a[2] = 20

Accessing beyond array bounds (unsafe):
Note: This may show garbage values or cause errors

Key Points

• Arrays in C have a fixed size that must be determined at compile time.
• All array elements must be of the same data type (homogeneous).
• C does not perform automatic boundary checking, which can lead to buffer overflows.
• Insertion and deletion operations require shifting elements, making them inefficient.

Conclusion

While arrays are fundamental data structures in C, they have significant limitations including fixed size, homogeneous data requirements, and lack of boundary checking. Understanding these limitations helps programmers choose appropriate data structures for their applications.