C Pointer to Array vs Array of Pointers: How to Read Complex Declarations

By the end of this page, you will understand how to tell apart an array of pointers from a pointer to an array in C. You will also learn a reliable rule for reading complex C declarations, so syntax like int *arr1[8] or int (*arr2)[8] becomes much easier to decode.

C declarations can look confusing because symbols like *, [], and () combine in ways that change meaning.

The key idea is that arrays and pointers are different types, even though they are often related.

Consider these declarations:

int *arr1[8];
int (*arr2)[8];
int *(arr3[8]);

What each one means

int *arr1[8];

arr1 is an array of 8 elements, where each element is a pointer to int.

• arr1[0] is an int *
• arr1[1] is an int *
• and so on

int (*arr2)[8];

arr2 is a pointer to an array of 8 integers.

Think of C declarations like reading a road sign from the variable name outward.

Start at the variable name, then look:

• to the right first if possible
• then to the left
• use parentheses as barriers that group things together

Analogy

Imagine the variable name is a person in the middle of a maze.

• If the first thing they touch is [], they are an array.
• If the first thing they touch is *, they are a pointer.
• Parentheses can change which path they must take first.

For example:

int *arr1[8];

Start at arr1:

• right: [8] → arr1 is an array of 8
• left: * → whose elements are pointers
• base type: int

So: array of 8 pointers to int.

Now:

int (*arr2)[8];

Start at :

Core syntax

int *a[8];     // array of 8 pointers to int
int (*b)[8];   // pointer to array of 8 int

Example 1: Array of pointers

#include <stdio.h>

int main(void) {
    int x = 10, y = 20, z = 30;
    int *arr[3] = { &x, &y, &z };

    printf("%d\n", *arr[0]);
    printf("%d\n", *arr[1]);
    printf("%d\n", *arr[2]);

    return 0;
}

arr is an array. Each element stores the address of an int.

• arr[0] is int *
• *arr[0] is the value stored at that address

Consider this example:

#include <stdio.h>

int main(void) {
    int numbers[4] = { 5, 10, 15, 20 };
    int (*p)[4] = &numbers;

    printf("%d\n", (*p)[2]);
    return 0;
}

Step-by-step

1. Declare an array

int numbers[4] = { 5, 10, 15, 20 };

numbers is an array of 4 integers.

2. Declare a pointer to the whole array

int (*p)[4] = &numbers;

Read it from p:

• * means pointer

Where array-of-pointers is used

List of strings

char *names[3] = { "Alice", "Bob", "Carol" };

Each element points to the first character of a string.

Sparse or flexible row storage

You can store pointers to separately allocated rows in a table-like structure.

int *rows[10];

Each row can point to a different memory block.

Lookup tables

An array of pointers is useful when each entry refers to another object or buffer.

Where pointer-to-array is used

Passing fixed-size arrays to functions

void print_row(int (*row)[8]);

This says the function expects a pointer to an array of 8 integers.

Working with multidimensional arrays

int matrix[5][8];
int (*row)[8] = matrix;

In real codebases, developers use these forms to make intent explicit.

Common patterns

1. Function parameters for fixed-width rows

void process_rows(size_t count, int (*rows)[8]) {
    for (size_t i = 0; i < count; i++) {
        printf("%d\n", rows[i][0]);
    }
}

This is common with matrices, image data, and protocol packets.

2. Arrays of pointers for dynamic collections

char *errors[5];

Useful when each element may point to a different string or object.

3. Validation and guard clauses

void print_first(int (*arr)[8]) {
    if (arr == NULL) {
        return;
    }
    printf("%d\n", (*arr)[0]);
}

Pointer checks are common before dereferencing.

4. APIs that distinguish contiguous memory from indirect storage

1. Assuming arrays and pointers are always the same

They are related, but not identical types.

Broken thinking:

int *a[8];
int (*b)[8];

b = a;   // wrong: incompatible types

Why it fails:

• a is an array of pointers
• b is a pointer to an array of int

2. Ignoring parentheses

int *a[8];    // array of pointers
int (*a)[8];  // pointer to array

A small change in parentheses creates a different type.

3. Dereferencing the wrong thing

Broken example:

int values[3] = {1, 2, 3};
int (*p)[3] = &values;
printf("%d\n", *p[1]);

Why this is wrong:

array of pointers vs pointer to array

Quick reading rule

Start at the variable name:

1. Look right first
2. Then look left
3. Parentheses control grouping
4. [] and () bind tighter than *

Common patterns

int *a[8];        // array of 8 pointers to int
int (*a)[8];      // pointer to array of 8 int
int (*f)(void);   // pointer to function returning int
int *f(void);     // function returning pointer to int

Your declarations

int *arr1[8];     // array of 8 pointers to int
int (*arr2)[8];   // pointer to array of 8 int
int *(arr3[8]);   // same as int *arr3[8]

Important precedence

• [] has high precedence

What is the difference between int *a[8] and int (*a)[8] in C?

int *a[8] is an array of 8 pointers to int. int (*a)[8] is a pointer to one array of 8 integers.

Are int *arr1[8] and int *(arr3[8]) the same?

Yes. They mean the same thing: an array of 8 pointers to int.

Why do parentheses matter in C declarations?

Parentheses change grouping. Since [] binds more tightly than *, parentheses can force * to apply first.

How do I read complex C declarations correctly?

Start at the variable name, read to the right when possible, then to the left, and use parentheses to determine grouping.

Is an array the same as a pointer in C?

No. Arrays and pointers are different types. Arrays often decay to pointers in expressions, but they are not identical.

What type is &arr if arr is int arr[8]?

Array decay

Arrays often convert to pointers in expressions, which is why they are commonly confused with pointers.

Operator precedence in C

Understanding why [] binds before * is essential for reading declarations.

Function pointers

Function pointer syntax uses the same grouping rules and often confuses learners in similar ways.

Multidimensional arrays

Pointers to arrays are very common when working with matrices like int matrix[3][8].

typedef in C

typedef can simplify hard-to-read declarations and make APIs easier to understand.

Dereferencing and indexing

Expressions like *p, p[i], and (*p)[i] depend directly on the declared type.