PREV_LEC NEXT_LEC

Prerequisites

You should be comfortable with the previous lecture on multidimensional array layout, including the fact that m for int m[3][4] decays to int (*)[4]. Familiarity with C strings helps for the command-table example.

Reading C Declarations: The Right-Left Rule

Start at the name. Read to the right until you hit a closing parenthesis or the end, then read to the left, and repeat. Brackets bind tighter than the star, which is why the parentheses matter.

Memory Picture: Pointer Array vs Pointer to Array

Run the Comparison

Save this as ep_ptr_arrays.c. The first half fills both pointer styles from the same table. The second half builds a small ragged table of modem-style command strings, a natural use for an array of pointers.

#include <stdio.h>
#include <string.h>

int main(void)
{
    int grid[3][4] = {{10, 11, 12, 13}, {20, 21, 22, 23}, {30, 31, 32, 33}};
    int *row_ptrs[3];            /* array of 3 pointers to int      */
    int (*grid_ptr)[4];          /* pointer to an array of 4 ints   */

    for (int i = 0; i < 3; i++)
        row_ptrs[i] = grid[i];
    grid_ptr = grid;

    printf("sizeof row_ptrs=%zu  grid_ptr=%zu  *grid_ptr=%zu\n",
           sizeof row_ptrs, sizeof grid_ptr, sizeof *grid_ptr);
    printf("%d %d %d\n", row_ptrs[0][0], row_ptrs[0][1], row_ptrs[2][3]);
    printf("%d %d %d\n", grid_ptr[0][0], grid_ptr[0][1], grid_ptr[2][3]);
    printf("row_ptrs+1 steps %td bytes, grid_ptr+1 steps %td bytes\n",
           (char *)(row_ptrs + 1) - (char *)row_ptrs,
           (char *)(grid_ptr + 1) - (char *)grid_ptr);

    const char *cmds[] = {"AT", "AT+CSQ", "AT+CREG?"};
    for (size_t i = 0; i < sizeof cmds / sizeof cmds[0]; i++)
        printf("cmd %zu: %-9s len=%zu\n", i, cmds[i], strlen(cmds[i]));
    return 0;
}

Build and Run

$ gcc -Wall -Wextra -std=c11 -o ep_ptr_arrays ep_ptr_arrays.c
$ ./ep_ptr_arrays
sizeof row_ptrs=24  grid_ptr=8  *grid_ptr=16
10 11 33
10 11 33
row_ptrs+1 steps 8 bytes, grid_ptr+1 steps 16 bytes
cmd 0: AT        len=2
cmd 1: AT+CSQ    len=6
cmd 2: AT+CREG?  len=8

What the Numbers Say

Subscripting reads identically for both, which is why the two look interchangeable. The difference is what lives behind that subscript. For row_ptrs[2][3] the CPU loads a pointer from the array and then an int from wherever it points. For grid_ptr[2][3] it computes the address with arithmetic alone and loads one int.

Array of Pointers in Embedded C: Where It Shines

• Command and string tables. The cmds array above holds strings of different lengths with no wasted padding. Declare it as const char *const cmds[] so both the table and the strings sit in flash.
• Ragged data. Rows of different lengths, such as per-channel calibration lists, fit naturally.
• Dispatch tables. An array of function pointers indexed by an opcode or interrupt number is the same idea with a different pointee.
• Reordering without copying. To sort big records, sort an array of pointers to them and leave the data where it is.

Pointer to Array: Where It Shines

• Walking a real 2-D table. One pointer, with no extra storage, steps row by row.
• Function parameters. void scale_rows(int (*m)[4], size_t rows) accepts any table with four columns and lets you write m[r][c] inside.
• Fixed-size frames. A buffer of equal-length packets, each 16 bytes, processed one packet per step.

Make It Readable With typedef

A typedef turns the awkward spelling into something a teammate can read at a glance:

typedef int row4_t[4];            /* one row of four ints */

void scale_rows(row4_t *m, size_t rows);   /* same as int (*m)[4] */

Choosing Between Them

Common Mistakes and Troubleshooting

Best Practices

• Use const char *const for string tables so nothing can be changed or reassigned, and the linker can place them in flash.
• Compute table length once with sizeof tab / sizeof tab[0] and never hard-code it a second time.
• Use typedefs for row types and function-pointer types.
• Prefer plain 2-D arrays and pointers to arrays for numeric tables, to avoid extra indirection.
• Annotate tables with a comment saying who owns the pointed-to storage.

Performance and Security Considerations

An extra pointer load per access is a small cost but can matter in a tight loop on a core without a cache. On the security side, a table of pointers into writable memory is a tempting target. Keep dispatch and string tables const so they cannot be overwritten at run time, and bounds-check every index that comes from outside the device.

Suggested Images

Summary and Key Takeaways

Conclusion

Declarations in C are not hard once you read them from the name outward. With that skill, the pair of look-alike declarations stops being a puzzle and becomes a design choice between flexibility and compactness. In the final lecture of this chapter we pull the whole pointers chapter together with a recap, a quiz and interview questions.

FAQ: Array of Pointers vs Pointer to Array

PREV_LEC NEXT_LEC