Array in C Language with Example

In C, an array is a collection of elements of the same data type that are stored in contiguous memory locations. Arrays provide a convenient way to store and access multiple values using a single variable name. Here's an example of working with arrays in C:

```c
#include <stdio.h>

int main() {
    // Declaration and initialization of an integer array
    int numbers[5] = {10, 20, 30, 40, 50};

    // Accessing array elements
    printf("The third element is: %d\n", numbers[2]);

    // Modifying array elements
    numbers[1] = 25;
    printf("Modified second element: %d\n", numbers[1]);

    // Iterating over array elements
    printf("All array elements: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    // Array length or size
    int length = sizeof(numbers) / sizeof(numbers[0]);
    printf("Array length: %d\n", length);

    return 0;
}
```

Output:
```
The third element is: 30
Modified second element: 25
All array elements: 10 25 30 40 50
Array length: 5
```

In the above example:

- We declared and initialized an integer array named `numbers` with 5 elements.
- Individual array elements can be accessed using the index within square brackets (`[]`). The index starts at 0, so `numbers[0]` refers to the first element.
- We modified the value of the second element (`numbers[1]`) to 25.
- Using a `for` loop, we iterated over all array elements and printed their values.
- The `sizeof` operator is used to calculate the total size of the array and divide it by the size of a single element to determine the length of the array.

Arrays in C provide a powerful and efficient way to work with multiple values of the same type. They are commonly used in various programming scenarios, such as storing data, performing calculations, and implementing data structures like lists, stacks, and queues.

 

 

Certainly! Here are some additional examples of working with arrays in C:

1. Sum of Array Elements:
```c
#include <stdio.h>

int main() {
    int numbers[] = {2, 4, 6, 8, 10};
    int sum = 0;

    for (int i = 0; i < sizeof(numbers) / sizeof(numbers[0]); i++) {
        sum += numbers[i];
    }

    printf("Sum of array elements: %d\n", sum);

    return 0;
}
```
Output: Sum of array elements: 30

2. Finding Maximum Element in an Array:
```c
#include <stdio.h>

int main() {
    int numbers[] = {7, 2, 9, 4, 6};
    int max = numbers[0];

    for (int i = 1; i < sizeof(numbers) / sizeof(numbers[0]); i++) {
        if (numbers[i] > max) {
            max = numbers[i];
        }
    }

    printf("Maximum element: %d\n", max);

    return 0;
}
```
Output: Maximum element: 9

3. Reversing an Array:
```c
#include <stdio.h>

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int length = sizeof(numbers) / sizeof(numbers[0]);

    printf("Original array: ");
    for (int i = 0; i < length; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    for (int i = 0, j = length - 1; i < j; i++, j--) {
        int temp = numbers[i];
        numbers[i] = numbers[j];
        numbers[j] = temp;
    }

    printf("Reversed array: ");
    for (int i = 0; i < length; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    return 0;
}
```
Output: Original array: 1 2 3 4 5
        Reversed array: 5 4 3 2 1

These examples demonstrate some common operations on arrays, including summing the elements, finding the maximum element, and reversing the array. They showcase the versatility and power of arrays in performing various computations and manipulations.