1D Array in C

The one-dimensional (1D) array is a collection of elements of the same data type arranged in a linear sequence. Each element in the array is accessed by its position or index. The elements are stored in contiguous memory locations, making it easy to iterate through them using loops or pointers. Here’s how you declare, initialize, and work with 1D arrays in C:

Declaration:
To declare a 1D array, you specify the data type of its elements followed by the array name and the number of elements enclosed in square brackets []. For example:

int numbers[5]; // Declares an integer array named numbers with 5 elements

Initialization:
You can initialize a 1D array when declaring it or later in your code. Here are examples of both approaches:

int numbers[5] = {10, 20, 30, 40, 50}; // Initializing during declaration

int numbers[5]; // Declaring an array
numbers[0] = 10; // Initializing individual elements
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;

Accessing Elements:
You can access elements of a 1D array using their indices. Array indices in C are zero-based, meaning the first element has an index of 0, the second element has an index of 1, and so on. For example:

int x = numbers[0]; // Accesses the first element (10)
int y = numbers[2]; // Accesses the third element (30)

Iterating Through an Array:
You can use loops, such as for or while loops, to iterate through the elements of a 1D array. For example:

for (int i = 0; i < 5; i++) {
    printf("%d ", numbers[i]); // Prints each element
}

Array Length:
In C, arrays do not store their length directly, so you need to keep track of the array’s length separately if needed. The sizeof operator can be used to calculate the size (in bytes) of the array, and you can divide it by the size of an individual element to find the number of elements in the array. For example:

int length = sizeof(numbers) / sizeof(numbers[0]);
printf("Array length: %d\n", length); // Prints the length of the array (5)

1D arrays are widely used in C for storing and manipulating collections of data, and they provide a foundation for more complex data structures and algorithms. Keep in mind that C does not perform bounds checking on array accesses, so it’s essential to ensure that you do not access elements beyond the array’s bounds to avoid undefined behavior.