Basic Concepts and Storage Methods of Arrays

Basic Concepts of Arrays in C

Declaration and Initialization

Arrays in C are declared by specifying the data type, array name, and size. For example:

int arr[5];  // A 1D array of 5 integers

The size of an array is a constant, and it must be known at compile time. Elements are initialized during declaration or explicitly assigned later.

Accessing Elements

Elements in an array are accessed using an index, which starts at 0 and increments by 1 for each subsequent element. For example:

arr[0] = 10;  // Assigns 10 to the first element

The maximum index is size - 1, where size is the array's size.

Storage in Contiguous Memory

Arrays are stored in contiguous memory locations. The first element is at address 0, and each subsequent element is stored at the next address. For a 1D array of size n, the last element occupies address n - 1.

---

Storage Methods of Arrays

Static Arrays

Static arrays have a fixed size and are declared with a specified size. They are stored in contiguous memory and are initialized during declaration. For example:

int staticArray[10];  // A 10-element array

Static arrays are allocated at runtime and are not resized.

Dynamic Arrays

Dynamic arrays are allocated at runtime using malloc or calloc. They are declared with int* arr = malloc(size * sizeof(int)); and must be manually managed for memory safety.

---

Multidimensional Arrays

Declaration and Initialization

Multidimensional arrays are declared by specifying multiple dimensions. For example:

int matrix[2][3];  // A 2x3 array

The size of a multidimensional array is the product of the sizes of each dimension. For matrix[2][3], the total number of elements is 2 * 3 = 6.

Accessing Elements

Elements in a multidimensional array are accessed using multiple indices. For example:

matrix[1][2] = 42;  // Assigns 42 to the element at row 1, column 2

Indices must be within valid ranges, such as 0 <= row < rows and 0 <= column < columns.

Storage in Contiguous Memory

Multidimensional arrays are stored in contiguous memory, with each row stored consecutively. For a 2D array of size rows x cols, the total number of elements is rows * cols.

Row-Major Order

Elements are stored in row-major order, meaning the first row is stored first, followed by the second row, and so on. For example, matrix[0][0], matrix[0][1], matrix[0][2], matrix[1][0], ...

---

Key Considerations

Indexing and Bounds

Indices must be non-negative and less than the array's size. Negative indices are not allowed, and out-of-bounds access can lead to undefined behavior.

Memory Allocation

Static arrays are allocated at compile time, while dynamic arrays are allocated at runtime. Dynamic arrays require manual memory management to avoid leaks.

Size Determination

The size of an array is determined by the last index. For example, int arr[5] has a size of 5, and the maximum index is 4.

Practical Examples

// 1D Array
int arr[5] = {1, 2, 3, 4, 5};
printf("%d\n", arr[2]);  // Outputs 3

// 2D Array
int matrix[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};
printf("%d\n", matrix[1][1]);  // Outputs 5

These examples demonstrate how to declare, access, and use arrays in C, emphasizing the importance of indexing and storage methods.