Why `a[5]` Equals `5[a]` in C: Array Indexing and Pointer Arithmetic Explained

By the end of this page, you will understand how C array indexing is defined, why a[i] is really shorthand for *(a + i), and why that makes a[5] and 5[a] equivalent. You will also see how this relates to pointers, arrays, memory addresses, and common mistakes beginners make when working with them.

In C, the array subscript operator [] is defined in terms of pointer arithmetic.

The key rule is:

a[i]  ==  *(a + i)

This means:

• a refers to the starting address of the array's first element in most expressions
• i is an offset
• a + i means “move forward i elements”
• *(a + i) means “read the value at that computed address”

Because addition is commutative, these two expressions are equivalent:

a + i
i + a

So:

a[i] == *(a + i)
     == *(i + a)
     == i[a]

That is why a[5] and 5[a] access the same element.

Why this matters

This is important because arrays and pointers are closely related in C:

• arrays often decay to pointers in expressions
• pointer arithmetic is scaled by the size of the pointed-to type
• indexing syntax is just a convenient way to use pointer offsets

Understanding this helps you read C code correctly and avoid memory bugs.

Think of an array like a row of mailboxes.

• a is the location of the first mailbox
• 5 means “move 5 boxes forward”
• *(a + 5) means “open the mailbox 5 positions after the first one”

Now imagine giving directions:

• “start at a, move 5”
• “move 5 from a”

Both describe the same destination.

That is why:

a[5]

and

5[a]

lead to the same mailbox.

The [] operator in C is really just a convenient way of saying “go to this base address, then move by this offset, then dereference.”

The core indexing rule in C is:

x[y] == *(x + y)

That means either side of [] participates in address calculation.

Basic example

#include <stdio.h>

int main(void) {
    int a[] = {10, 20, 30, 40, 50, 60};

    printf("a[5] = %d\n", a[5]);
    printf("5[a] = %d\n", 5[a]);

    return 0;
}

Output:

a[5] = 60
5[a] = 60

Both print the same value.

Equivalent forms

int value1 = a[2];
int value2 = *(a + );
 value3 = *( + a);
 value4 = [a];

Consider this example:

#include <stdio.h>

int main(void) {
    int a[] = {11, 22, 33, 44, 55, 66};
    int result = 5[a];
    printf("%d\n", result);
    return 0;
}

Step-by-step

1. The array is created

int a[] = {11, 22, 33, 44, 55, 66};

Memory conceptually looks like this:

Most programmers do not write 5[a] in production code, because it is confusing. But the idea behind it appears everywhere.

1. Accessing array elements

int nums[] = {4, 8, 15, 16, 23, 42};
int x = nums[3];

This is really pointer arithmetic under the hood.

2. Iterating through buffers

char message[] = "hello";
for (int i = 0; message[i] != '\0'; i++) {
    printf("%c\n", message[i]);
}

Each message[i] is *(message + i).

3. Working with strings

C strings are character arrays, so indexing is extremely common:

char *name = "Alice";
printf("%c\n", name[1]);

4. Parsing binary data

In real C codebases, developers rely on indexing and pointer arithmetic in practical, readable ways.

Common patterns

Guarding bounds before indexing

int get_value(int *arr, int length, int index) {
    if (index < 0 || index >= length) {
        return -1;
    }
    return arr[index];
}

This avoids out-of-bounds access.

Iterating with indexes

for (int i = 0; i < length; i++) {
    total += arr[i];
}

This is usually clearer than writing explicit pointer arithmetic.

Iterating with pointers

for (int *p = arr; p < arr + length; p++) {
    total += *p;
}

This is equivalent in spirit, and sometimes preferred in low-level code.

Using early validation

int read_char(const char *text,  index) {
     (text ==  || index < ) {
         ;
    }
     text[index];
}

1. Thinking arrays and pointers are identical

They are related, but not the same.

int a[10];
int *p = a;

• a is an array of 10 integers
• p is a pointer to int

They behave similarly in many expressions, but they are different types.

2. Forgetting that indexing is pointer arithmetic

Some beginners think a[i] is special syntax only for arrays. But pointers can be indexed too:

int *p = a;
printf("%d\n", p[2]);

This works because p[2] means *(p + 2).

3. Going out of bounds

int a[3] = {1, 2, 3};
printf("%d\n", a[5]);  // wrong

x[y] == *(x + y)

Core rules

• a[i] means element i from base a
• a[i] is exactly the same as *(a + i)
• therefore i[a] is also valid
• pointer arithmetic moves in units of the pointed-to type
• a + 1 for int *a moves by sizeof(int) bytes

Examples

int a[] = {10, 20, 30};

a[1];      // 20
*(a + 1);  // 20
1[a];      // 20

Not the same

*a + 1     // first element plus 1
*(a + 1)   // second element

Remember

Why is 5[a] valid in C?

Because array subscripting is defined as *(a + i). Since a + i and i + a are equivalent, 5[a] means the same as a[5].

Is 5[a] good style?

No. It is valid, but unusual and confusing. Use a[5] in normal code.

Does this only work for arrays?

No. It also works for pointers:

int *p = a;
p[2];
2[p];

Are arrays and pointers the same in C?

Not exactly. Arrays and pointers are different types, but array names often decay to pointers in expressions.

Why does a + 1 move by one element instead of one byte?

Because pointer arithmetic is scaled by the size of the pointed-to type.

What does *(a + i) mean?

It means: start at address a, move forward i elements, then read the value stored there.

• Pointers — Array indexing in C is built on pointer arithmetic.
• Arrays in C — Arrays provide contiguous storage and are the usual object being indexed.
• Pointer arithmetic — Explains how adding an integer to a pointer moves by elements.
• Dereferencing — *(a + i) reads the value at a computed address.
• Array decay — Array names often become pointers to their first element in expressions.
• Memory layout — Helps explain why contiguous elements can be reached by offsets.
• Undefined behavior — Important when indexing outside array bounds.
• Function parameters and arrays — Shows why array parameters often behave like pointers.