Exploring Pointers in C Language (Part 2): Pointer Arrays and Array Pointers

Continuing from the previous article, we will further discuss pointers in the C language.In C, pointers and arrays are two closely related but often confused concepts. When combined, they form two powerful tools:Pointer Arrays and Array Pointers.

1. Pointer Arrays: A Tool for Managing Collections of Data

1.1 What is a Pointer Array?

A pointer array is an array where each element is a pointer. The declaration format is:type *array_name[size].

First, a pointer array is an array. This means it occupies a block of contiguous memory. This array has a fixed size, and we can access each element through indexing (names[0], names[1]).
Second, its element type is a pointer. This is key. The array does not store actual data (like characters, integers, or structures), but rather the addresses pointing to this data. You can think of the array as an apartment building, where each room (array element) does not house a person, but rather a note saying “someone lives at XX address” (pointer).

For example, the following declaration:

// Declare an array containing 4 character pointers

const char *names[] = {"Xiao Ming", "Xiao Hong", "Xiao Gang", "Xiao Mei"};

names is an array.
Each of its elements, namely names[0], names[1], etc., has the type const char * (pointer to constant characters).
The initialization list contains "Xiao Ming", "Xiao Hong", etc., which are string literals, stored in the read-only data segment (commonly referred to as the .rodata segment).
Thus, the initialization process of the array is: assigning the memory address of the string "Xiao Ming" in the read-only data segment to names[0], assigning the address of "Xiao Hong" to names[1], and so on.

1.2 Memory Layout and Working Principle

The overall layout of a pointer array in memory is as follows:

Assuming the addresses are simplified, the structure in memory might look like this:

The working principle of a pointer array is as follows: When the program executes printf("%s", names[0]);:

The CPU finds the starting address of the names array, for example, 0x1000.
Using the index [0], it calculates the address of the first element:0x1000 + (0 * sizeof(pointer)) = 0x1000.
Dereferencing this address retrieves the stored value:0x2000. This value is not the data itself, but a pointer to the data.
The CPU then jumps to address 0x2000.
Starting from 0x2000, it reads characters byte by byte until it encounters the string terminator \0, then outputs these characters to the screen. Thus, it prints "Xiao Ming".

This process is called “address access”, where the pointer array acts as an intermediary directory or routing table.

1.3 Advantages and Applicable Scenarios

Efficient storage of data of varying lengths (especially strings):

Imagine if you used a two-dimensional character array instead of a pointer array:char names[4][10] = {"Xiao Ming", "Xiao Hong", ...};. You must specify the second dimension (the maximum length of each string) to be the maximum value among all possible strings, such as 10. For shorter strings like “Xiao Hong” (which occupies 5 bytes: 3 Chinese characters + 1 \0), you waste 5 bytes of space. In contrast, a pointer array only stores addresses (typically 8 bytes), and the strings themselves occupy only as much space as they need, making the storage of pointers very compact.

Memory savings:

As mentioned above, it avoids the waste of reserving maximum space for each element. When managing a large number of strings of varying lengths, the memory savings can be substantial.

High flexibility:

Efficient sorting: If you want to sort a collection of strings alphabetically, swapping strings in a two-dimensional array requires a lot of memory copying (strcpy). In contrast, swapping elements in a pointer array only requires swapping the values of two pointers (two addresses), which is several orders of magnitude faster and does not affect the original string storage locations.
Dynamic replacement: You can easily point a pointer to a new string without moving the original string. For example, names[0] = "Da Ming";, this statement simply changes the address stored in names[0] from 0x2000 (the address of Xiao Ming) to the address of the new string "Da Ming". This is very efficient.

Classic Applications

Error Message Table: Managing with a pointer array is very intuitive, error codes can be directly used as indices (error_messages[ERR_NO_MEMORY]<code>), making the code highly readable.
Command Line Arguments argv: The operating system parses user input parameters into strings and then creates a pointer array (char *argv[]) to store the addresses of these strings, passing the address of the array to the main function. The lengths of the parameters vary, and a pointer array is the only natural way to store them.

1.4 Dynamic Memory Allocation Example – Expanding from Static to Dynamic

char **arr: arr is a pointer to a pointer. It can be used as the name of a pointer array.
malloc(size * sizeof(char *)): Allocates a contiguous block of memory on the heap, sized for size pointers. This memory serves the same purpose as the previously statically defined names array, used to store char * type pointers. At this point, each pointer in the array is uninitialized (possibly garbage values).

This function allocates another block of memory on the heap for each pointer in the first dimension of the array arr[i] to store the actual string data.
This forms a dynamic two-dimensional structure that is much more flexible than a static two-dimensional array. You can decide at runtime how many rows this “array” has (through the first malloc of size), and how long each row is (through the second malloc, allowing each string to have a different length).

1.5 Common Pitfalls and Solutions – Critical Details

Pitfall 1: Modifying String Literals This is a very common mistake in C.

Root Cause: String literals like "Alice" are not mandated by the C standard to be stored in read-only memory, but almost all modern compilers do so for optimization and sharing. Attempting to modify read-only memory will cause the program to crash (e.g., Segment Fault).
Solution 1 (Using const): const char *names[] = {...}; This is defensive programming. The const keyword tells the compiler: “The things these pointers point to are constants and cannot be modified.” If you try to write names[0][0] = 'E';, the compiler will report an error at compile time, preventing runtime disasters. This is the preferred method if you do not need to modify these strings.
Solution 2 (Using Array Initialization): char name1[] = "Alice"; This line does something entirely different. It creates a character array named name1 on the stack (if it is a local variable) and copies the string "Alice" (including the terminator \0) into this array to initialize it. The contents of this array are fully modifiable. Then, use the address of this modifiable array to initialize the pointer array. This is a strategy of “sacrificing some space (each string has a copy) for modifiability”.

Pitfall 2: Memory Leaks This is a core issue in dynamic memory management.

Root Cause: Every byte of heap memory allocated from the system (via malloc, calloc, etc.) must have a corresponding free to return it. If you only free the pointer array itself (array), but forget to release the memory pointed to by each pointer in the array (array[0], array[1], …), then the memory occupied by these strings can never be reused by the program, causing a memory leak. For long-running programs (like servers or daemons), even small leaks can accumulate and lead to memory exhaustion.
Release Principle: Release in reverse order. The order of release should be the reverse of the order of allocation. First, release the “leaves” (the deepest data), then release the “branches” (the structures containing pointers).

for loop: Release the memory of each pointer pointing to the string (free(array[i])).
Finally, release the array itself that stores these pointers (free(array)).

If you only perform step 2 without step 1, then the memory of all strings will be leaked. If you perform step 2 before step 1, then the array[i] in step 1 has already become a dangling pointer, and accessing it again to free will lead to undefined behavior (most likely a crash). Therefore, the order is crucial.

2. Array Pointers: Professional Tools for Handling Multi-Dimensional Arrays

2.1 What is an Array Pointer? – A Pointer to an Entire Array

An array pointer is a pointer that points to an entire array. The declaration format is:type (*pointer_name)[size]

This definition sharply contrasts with pointer arrays and is one of the most confusing points in the concept of pointers in C. The key is to understand the unit of the “entire array”.

Pointer Array: int *arr[10] -> An array containing 10 elements, each of which is an int* (priority: [] > *).
Array Pointer: int (*ptr)[10] -> A pointer that points to an array containing 10 int elements (using () changes the priority, so ptr binds with * first).

Code Example:

matrix is a two-dimensional array, which can be understood as “an array containing 3 elements, each of which is itself an array containing 4 integers”.
ptr is a pointer. Its type is int (*)[4], which means “a pointer to an array containing 4 integers”.
matrix as an array name, in most expressions, will “decay” to point to its first element.matrix’s first element is its first row, which is an int [4] type array. Therefore, the decay of matrix results in a pointer to an int [4] array, which matches the type of ptr, allowing assignment.

2.2 Memory Layout and Working Principle – Stepping by Rows

Assuming the starting address of matrix is 0x1000, and int occupies 4 bytes.

Now, ptr = matrix; means the address value stored in ptr is 0x1000.

The essence of pointer arithmetic:

ptr + 1: Here, the 1 unit is the size of the object pointed to by ptr<code>. <code>ptr points to an int [4], which is an array containing 4 integers, with a size of 4 * sizeof(int) = 16<code> bytes. Therefore, <code>ptr + 1 will add 16 bytes to 0x1000, resulting in the address 0x1010, which is the starting address of the second row (matrix[1]).
*(ptr + 1): Dereferencing ptr + 1 (the pointer to the second row) retrieves the second row array itself (matrix[1]). The array name in the expression will decay to point to its first element, so *(ptr + 1) is equivalent to matrix[1], which is of type int*, pointing to matrix[1][0] (address 0x1010).
*(ptr + 1) + 2: The starting address of the second row (0x1010) plus 2 * sizeof(int) = 8 bytes results in the address 0x1018, pointing to matrix[1][2].
*(*(ptr + 1) + 2): Dereferencing the above address retrieves the value matrix[1][2] (7).

This is why we can use ptr[i][j] syntax that looks just like an array. The compiler will convert it to *(*(ptr + i) + j)<code>.

2.3 Advantages and Applicable Scenarios

Simplifying Multi-Dimensional Array Handling (Function Parameters):

Method A: Pass a Flattened Pointer and One-Dimensional Index (int *arr, int rows, int cols)
Method B: Pass a Pointer Array (int **arr, int rows, int cols)
Method C: Pass an Array Pointer(int (*arr)[4], int rows)

Accessing elements within the function:arr[i * cols + j]
Disadvantages: The syntax is not intuitive and can easily lead to index calculation errors.

Disadvantages: This requires that the two-dimensional array itself must be dynamically allocated in the form of a pointer array, and cannot be used for a int matrix[3][4] which is a real two-dimensional array. The memory layout is completely different.

Advantages: Inside the function, you can use the most natural arr[i][j] syntax to access elements. It perfectly matches the memory model of statically defined two-dimensional arrays, making it the most type-safe and intuitive syntax for passing.

This is the primary and irreplaceable use of array pointers. In C, you cannot directly pass an entire array to a function by value. When you need to pass a two-dimensional array to a function, there are three common methods:

Improving Code Readability:

The function signature void print_matrix(int (*matrix)[4], int rows) clearly declares: “This function requires a two-dimensional array, where each row must contain 4 integers.” This itself serves as documentation.

Type Safety:

The compiler knows the length of each row. If you mistakenly try to access matrix[i][5], the compiler may issue a warning. In contrast, in Method A, the compiler has no idea how many cols there are, and cannot perform any boundary checks.

2.4 Dynamic Multi-Dimensional Array Handling – The Powerful Combination with VLA

int (*array)[cols]: Declares a pointer array that points to an integer array of length cols. Here, cols is a variable, which is the VLA type.
sizeof(*array): array points to an int [cols], so *array is an int [cols] type array. The result of sizeof(*array) is cols * sizeof(int). This is calculated at runtime.
malloc(rows * sizeof(*array)): Allocates a block of memory for rows rows, each of size sizeof(*array). This memory layout is identical to that of a static int rows[cols], being contiguous.
The return value int (*)[] is a pointer to an unspecified size array, and the caller needs to convert it to the correct type (like int (*)[cols]) for use.

process_2d_array function demonstrates how to directly use VLA array pointers in function parameters, allowing dynamic-sized two-dimensional arrays to have the same syntactic convenience as static arrays array[i][j], making it a powerful tool for writing numerical computation and image processing library functions.

2.5 Common Pitfalls and Solutions

Pitfall 1: Confusing Pointer Types

Error Cause: matrix decays to type int (*)[4] (a pointer to an array of 4 elements). Meanwhile, wrong_ptr has the type int * (a pointer to a single integer).
Although their values are both 0x1000, their types are completely different.
wrong_ptr + 1: Based on the size of int, it steps forward, resulting in 0x1000 + 4 = 0x1004 (pointing to matrix[0][1]).
correct_ptr + 1: Based on the size of int [4], it steps forward, resulting in 0x1000 + 16 = 0x1010 (pointing to matrix[1][0]).
If you try to simulate two-dimensional array access through wrong_ptr, the calculations will be completely incorrect, and the warnings given by the compiler are crucial and should never be ignored.

Pitfall 2: Array Dimension Mismatch

Error Cause: This is a strict type mismatch error.int (*)[4] and int (*)[5] are two completely different pointer types, just like int* and float* are different.
Compiler’s Role: The compiler reports an error to prevent catastrophic mistakes. If such an assignment were allowed, then ptr + 1 would advance by 5 * sizeof(int) = 20 bytes, while in reality, the next row is only 16 bytes apart. Any access through ptr would be misaligned, leading to data read/write confusion.
Solution: You must ensure that the dimensions of the array pointer match exactly with the dimensions of the actual array it points to. This is fundamental to ensuring code correctness.

3. Pointer Arrays vs Array Pointers: A Comprehensive Comparison

3.1 Declaration Syntax Comparison

3.2 Memory Layout Comparison

Memory layout of pointer arrays:

arr1[0] -> address1

arr1[1] -> address2

...

 arr1[9] -> address10

Memory layout of array pointers:

arr2 -> [starting address of the entire array]

3.3 Pointer Arithmetic Comparison

3.4 Application Scenario Comparison

4. Key Differences Mnemonic

A pointer array is an array where all elements are pointers; an array pointer is a pointer that points to an entire array.

Look at the declaration:int *arr[10] – first see [], so it is an array; int (*arr)[10] – first see *, so it is a pointer.

5. Selection Guide

If you need to manage a collection of data of different lengths → choose pointer arrays
If you need to handle multi-dimensional arrays while maintaining structure → choose array pointers
If you need a collection of data that can grow dynamically → choose pointer arrays
If you need to perform matrix operations → choose array pointers

6. Best Practices

Always initialize pointers: Avoid wild pointers
Use const to protect data: Prevent accidental modifications
Check for memory allocation failures: malloc may return NULL
Release memory in a timely manner: Avoid memory leaks
Use static arrays: When you need to return an array pointer

These personal views are for reference only; any issues are welcome for criticism and correction.