Using Arrays in C Programming

Of course! Arrays are one of the most fundamental and commonly used data structures in C language. Understanding the underlying principles of arrays not only helps you write efficient programs but also lays a solid foundation for learning pointers, memory management, and more.

1. What is an Array?

An array is a group of contiguous memory blocks of the same data type, accessed through **indices (subscripts)**.

int arr[5];  // Declare an array containing 5 ints

arr[0] is the first element
arr[4] is the last element
In C language, array indices start from 0!

2. Types of Arrays

1. Static Arrays (Stack Allocation)

int nums[3] = {1, 2, 3};  // Size determined at compile time

Characteristics:

Exists on the stack
Automatically allocated and released by the compiler
Fixed capacity

2. Dynamic Arrays (Heap Allocation)

int* nums = malloc(sizeof(int) * 3);
nums[0] = 1; nums[1] = 2; nums[2] = 3;

Characteristics:

Located in heap memory
Size can be determined at runtime
Requires manual free

3. Multidimensional Arrays (Example: Two-Dimensional)

int matrix[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

printf("%d\n", matrix[1][2]);  // Outputs 6

Essentially, it is contiguous memory arranged in row-major order.

3. Common Operations on Arrays

Declaration and Initialization

int arr[5] = {0};       // All elements initialized to 0
int arr2[] = {1, 2, 3}; // Automatically infers size as 3

Traversing an Array

for (int i = 0; i &lt; 5; ++i) {
    printf("%d\n", arr[i]);
}

Using Pointers to Operate on Arrays (Underlying Principles)

int arr[5] = {1, 2, 3, 4, 5};
int* p = arr;

printf("%d\n", *(p + 2));  // Equivalent to arr[2]

📌 In C, the array name is a pointer to the first element!

Arrays as Function Parameters

void printArray(int arr[], int size) {
    for (int i = 0; i &lt; size; i++)
        printf("%d ", arr[i]);
}

👉 In fact, int arr[] decays to int* pointer.

4. Use Cases for Arrays

Scenario	Example Explanation
Fixed Data Storage	Grade lists, RGB color values, configuration arrays
Strings (char arrays)	In C, strings are actually `<span>char</span>` arrays + `<span>\0</span>`
Array Processing	Sorting, searching, mapping, window algorithms, etc.
Matrix Processing	Two-dimensional arrays used for image pixels, graph structures, coordinate grids, etc.
Working with C Standard Library Functions	`<span>strcpy(char[])</span>`, `<span>memcpy(void*)</span>`, etc.
Buffers	I/O buffers, receiving network data, circular buffers, etc.

5. Limitations and Considerations of C Arrays

Issue/Risk	Description
❌ Cannot Automatically Resize	Fixed length, cannot grow like `<span>std::vector</span>`
❌ No Boundary Checking	Out-of-bounds access is undefined behavior (dangerous)
❌ Cannot Get Length	`<span>sizeof(arr)</span>` only works for local arrays, ineffective for parameters
❌ Does Not Support Assignment	`<span>arr1 = arr2;</span>` is illegal

6. Several Special Types of Arrays

1. Character Arrays and Strings

char name[] = "Tom";  // Includes \0, total length is 4

Can be used with <string.h>: strlen, strcpy, strcmp, …

2. Flexible Arrays (C99)

Flexible array members in structures, used for variable-length structures:

typedef struct {
    int len;
    int data[];  // Flexible array
} Packet;

Packet* pkt = malloc(sizeof(Packet) + sizeof(int) * 10);
pkt-&gt;len = 10;

3. Pointer Arrays vs Array Pointers

char* names[3];   // Pointer array: each element is a char*
char (*ptr)[10];  // Array pointer: points to an array of 10 chars

Distinction tips:

[] has higher precedence than *, read from right to left.

7. The Relationship Between Arrays and Pointers

Expression	Meaning
`<span>arr</span>`	Address of the first element (cannot be modified)
`<span>&arr[i]</span>`	Address of the i-th element
`<span>*(arr + i)</span>`	Value of the i-th element (same as `<span>arr[i]</span>`)
`<span>arr + i</span>`	Pointer to the i-th element

Arrays and pointers are essentially closely related, but not completely equivalent.

Conclusion: Core Knowledge of Arrays

Topic	Description
Uniform Type	All elements must be of the same type
Contiguous Memory	Supports high-performance access and pointer arithmetic
Fixed Size	Static array size is determined at compile time, dynamic arrays need manual management
Multidimensional Arrays	Used for grid data, images, matrices, etc.
Close Relationship with Pointers	Supports pointer traversal, function parameters, etc.
Works with Library Functions	`<span>memcpy</span>`, `<span>qsort</span>`, `<span>strcpy</span>`, `<span>scanf</span>`, etc.
Advanced Applications	Flexible arrays, variable-length arrays (VLA), nested array structures, etc.