Array of Pointers vs Pointer to Array in C

Both declarations contain an asterisk and a bracket pair. What separates them is which one binds to the name first. Brackets have higher precedence than the asterisk, so without parentheses the name is an array. With parentheses around the starred name, the name is a pointer.

Why Pointer Arithmetic Differs

Adding 1 to a pointer moves it by the size of the thing it points to. For ap, which decays to a pointer to int *, one step is one pointer wide. For pa, one step is the size of a full int[3]. You met the same effect for row pointers in the 2-D array lecture, where g + 1 jumped a whole row. A pointer to array is exactly what a 2-D array parameter becomes.

Build and Run the Comparison

Save this short program as ep_ptr_vs_array_ptr.c.

#include <stdio.h>
#include <stddef.h>

int main(void)
{
    int row[3] = {7, 8, 9};
    int x = 1, y = 2, z = 3;

    int *ap[3]   = { &x, &y, &z };   /* array of 3 pointers to int   */
    int (*pa)[3] = &row;             /* pointer to an array of 3 ints */

    printf("sizeof(ap)  = %zu   sizeof(pa)  = %zu   sizeof(*pa) = %zu\n",
           sizeof(ap), sizeof(pa), sizeof(*pa));

    printf("*ap[1]    = %d\n", *ap[1]);
    printf("(*pa)[1]  = %d\n", (*pa)[1]);

    printf("ap + 1 moves %td bytes\n", (char *)(ap + 1) - (char *)ap);
    printf("pa + 1 moves %td bytes\n", (char *)(pa + 1) - (char *)pa);
    return 0;
}

gcc -std=c11 -Wall -Wextra -o ep_ptr_vs_array_ptr ep_ptr_vs_array_ptr.c
./ep_ptr_vs_array_ptr

Expected output on a 64-bit Linux machine:

sizeof(ap)  = 24   sizeof(pa)  = 8   sizeof(*pa) = 12
*ap[1]    = 2
(*pa)[1]  = 8
ap + 1 moves 8 bytes
pa + 1 moves 12 bytes

What the Output Proves

• sizeof(ap) is 24: three pointers of 8 bytes each. sizeof(pa) is 8: a single pointer.
• sizeof(*pa) is 12: the pointed-to object is an array of three 4-byte integers.
• Element access differs: *ap[1] follows a stored pointer to y, while (*pa)[1] first dereferences to the array, then indexes it. The parentheses are essential, since *pa[1] would mean something else entirely.
• The step sizes, 8 and 12 bytes, are exactly the sizes of the objects each pointer targets.

Quick Recap of the Whole Block

In every case only a base address crosses the call, so the callee works on the caller’s original data, and any size that is not part of the pointed-to type must travel as a separate argument.

Common Mistakes and Troubleshooting

• Writing int *p[3] when you wanted a pointer to a 3-int array. The missing parentheses give you an array of pointers.
• Treating a 2-D array as int **. The types are incompatible; use a pointer to a row.
• Using sizeof on a parameter to find an element count.
• Forgetting that *pa[1] and (*pa)[1] are different expressions.

Best Practices, Performance and Security

• Write the pair (pointer, length) in every buffer function signature.
• Use const for read-only inputs and for tables you want in flash.
• Validate indexes and lengths that come from outside the program before using them.
• Use a typedef for complex declarators, such as a row type, when readability suffers.

Quiz: Test Your Understanding

Try each question before opening the answer. Assume a 64-bit Linux machine with 4-byte int unless a question says otherwise.

1. For void f(int a[10]);, what is sizeof(a) inside the function?

   • A) 40
   • B) 8
   • C) 10
   • D) 4
   Show answer

   B) 8. The parameter is an int *, so you get the pointer size. On a 32-bit microcontroller it would be 4.

2. Which prototypes are equivalent?

   • A) void f(int a[]);
   • B) void f(int a[5]);
   • C) void f(int *a);
   • D) All of the above
   Show answer

   D) All of the above. Each declares a pointer to int parameter.

3. What is int (*p)[4];?

   • A) An array of 4 pointers to int
   • B) A pointer to an array of 4 ints
   • C) A pointer to 4 ints separately
   • D) A syntax error
   Show answer

   B) A pointer to an array of 4 ints. The parentheses bind the star to p.

4. What is sizeof(int *q[4]) for a real array on a 64-bit system?

   • A) 8
   • B) 16
   • C) 32
   • D) 4
   Show answer

   C) 32. It is four pointers of 8 bytes each.

5. With int g[3][5]; int (*p)[5] = g;, how many bytes does p + 1 advance?

   • A) 4
   • B) 5
   • C) 20
   • D) 60
   Show answer

   C) 20. One step skips a full row of five 4-byte integers.

6. Can a function modify the elements of an array passed by the caller?

   • A) No, they are copied
   • B) Yes, it works on the original
   • C) Only if the array is global
   • D) Only with the register keyword
   Show answer

   B) Yes. The function receives the base address, so it works on the original array.

7. What does this print?

   static void bump(int *p) { p[2] += 10; p = NULL; }
   int v[4] = {1, 2, 3, 4};
   bump(v);
   printf("%d %d\n", v[2], v[0]);

   • A) 3 1
   • B) 13 1
   • C) 13 NULL
   • D) A crash
   Show answer

   B) 13 1. The element change is shared with the caller. Setting the local pointer to NULL affects only the callee’s copy of the pointer.

8. Is void f(int a[][]); valid?

   • A) Yes
   • B) No, inner dimensions must be given
   • C) Yes, but only in C99
   • D) Only if the first dimension is 1
   Show answer

   B) No. Only the leftmost dimension may be omitted, because the others determine the row size.

9. Inside a function with parameter int *buf, what does sizeof(buf) / sizeof(buf[0]) give on a 64-bit system?

   • A) The element count
   • B) 2
   • C) 8
   • D) 4
   Show answer

   B) 2. It is 8 divided by 4. The result has nothing to do with the real buffer length.

10. Given int *probe[3] = { &a, &b, &c };, what does *probe[1] = 0; do?

    • A) Sets probe[1] to 0
    • B) Sets b to 0
    • C) Sets all three to 0
    • D) Does not compile
    Show answer

    B) It sets b to 0. The subscript picks the pointer, and the star writes to its target.

Coding Challenge: Row Sums

Write a function that receives a matrix with a run-time width and fills an output array with the sum of each row. Try it yourself first, using what you learned about 2-D parameters. The function should take the row count, the column count, a read-only matrix and an output array.

#include <stdio.h>
#include <stddef.h>

static void row_sums(size_t rows, size_t cols, const int m[rows][cols], int out[rows])
{
    for (size_t r = 0; r < rows; r++) {
        int total = 0;
        for (size_t c = 0; c < cols; c++) {
            total += m[r][c];
        }
        out[r] = total;
    }
}

int main(void)
{
    int m[2][3] = {{1, 2, 3}, {4, 5, 6}};
    int sums[2];
    row_sums(2, 3, m, sums);
    printf("row sums: %d %d\n", sums[0], sums[1]);
    return 0;
}

gcc -std=c11 -Wall -Wextra -o row_sums row_sums.c
./row_sums
row sums: 6 15

Interview Questions on Arrays and Pointers

Conclusion

You have now covered how arrays travel into functions in one and two dimensions, why sizeof betrays you on array parameters, how an array of pointers organises scattered data, and how to tell it apart from a pointer to an array. These ideas are the daily bread of embedded C programming, and they are exactly what interviewers probe. Revisit the quiz after a day or two; repeating questions you got wrong is the quickest way to make the rules automatic. Keep going with the free C programming course, and continue to the next chapter block when you are ready.

Suggested Images for This Lecture

• Comparison diagram of an array of pointers and a pointer to an array. Alt text: “array of pointers vs pointer to array in C comparison diagram”.
• Terminal screenshot of the size and stride output. Alt text: “free C programming course array of pointers vs pointer to array in C program output”.
• Quiz summary graphic. Alt text: “embedded C programming interview quiz on arrays and pointers free embedded C course”.

Frequently Asked Questions