Pointers and Arrays in C: Decay, arr[i] = *(arr+i), and the sizeof Trap

Arrays and pointers are different things in C that behave the same way most of the time. That "most of the time" is what makes the topic slippery: code that treats an array as a pointer usually works, until the day it lands in one of the two places where the difference matters and the answer is silently wrong.

This page draws the line precisely.

Array Decay: The One Rule Behind Everything

In almost every expression, an array name is automatically converted to a pointer to its first element. This is called decay. arr becomes &arr[0], with type int *.

#include <stdio.h>

int main(void) {
    int arr[4] = {10, 20, 30, 40};

    printf("arr      = %p\n", (void *)arr);       // decays to &arr[0]
    printf("&arr[0]  = %p\n", (void *)&arr[0]);   // the same address
    printf("*arr     = %d\n", *arr);              // 10, the first element

    int *p = arr;                                  // no & needed - decay does it
    printf("*p       = %d\n", *p);

    return 0;
}

The array name and the address of its first element print identically. That is the decay in action, and it is why you can assign an array to a pointer with no &.

There are exactly three places decay does not happen: as the operand of sizeof, as the operand of &, and when initializing a character array from a string literal. Everywhere else, assume decay.

arr[i] Is Literally *(arr + i)

The C standard defines the subscript operator in terms of pointer arithmetic: a[b] means *(a + b). Indexing is not a separate feature - it is shorthand.

#include <stdio.h>

int main(void) {
    int arr[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d   *(arr + %d) = %d\n",
               i, arr[i], i, *(arr + i));
    }

    int *p = arr;
    printf("\np[2] = %d  (a pointer can be subscripted too)\n", p[2]);
    printf("2[arr] = %d  (legal, because addition commutes)\n", 2[arr]);

    return 0;
}

Two consequences fall out. First, a pointer can be subscripted: p[2] is *(p + 2), which is why functions receiving a pointer can still use familiar arr[i] syntax. Second, 2[arr] compiles - *(2 + arr) is the same address as *(arr + 2). Nobody writes that outside of a quiz, but it settles the question of whether indexing is "really" pointer arithmetic.

Passing an Array to a Function

Because of decay, a function never receives an array. It receives a pointer.

#include <stdio.h>

// these three declarations are IDENTICAL to the compiler
int sum_a(int arr[], int n);
int sum_b(int arr[100], int n);   // the 100 is ignored entirely
int sum_c(int *arr, int n);

int sum_c(int *arr, int n) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += arr[i];
    }
    return total;
}

int main(void) {
    int data[6] = {3, 1, 4, 1, 5, 9};
    int n = sizeof data / sizeof data[0];

    printf("n     = %d\n", n);
    printf("sum   = %d\n", sum_c(data, n));

    // works on a slice too - a pointer is just a starting position
    printf("tail  = %d\n", sum_c(data + 3, 3));

    return 0;
}

Three things worth pulling out of that example.

The size in int arr[100] is documentation, nothing more. The compiler rewrites the parameter to int *arr and never checks that you passed 100 of anything.

The length must travel separately. The function has an address and no idea how far the data extends. This is why virtually every array-taking C function takes a count: memcpy(dst, src, n), fread(ptr, size, count, f), qsort(base, nmemb, size, cmp). Strings are the exception only because they carry their own end marker, the '\0'.

Passing a pointer is cheap and the data is shared. No copy of the array is made, so the function can modify the caller's elements - that is often exactly what you want:

#include <stdio.h>

void double_all(int *arr, int n) {
    for (int i = 0; i < n; i++) {
        arr[i] *= 2;
    }
}

void print_all(const int *arr, int n) {   // const: promises not to modify
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main(void) {
    int values[5] = {1, 2, 3, 4, 5};

    print_all(values, 5);
    double_all(values, 5);
    print_all(values, 5);      // the caller's array really changed

    return 0;
}

Mark read-only parameters const int * as print_all does. It documents the intent and lets the compiler catch an accidental write.

The sizeof Trap

Here is the bug that catches every C programmer once. sizeof is one of the two places decay does not happen - so it gives the true array size where the array is declared, and the size of a pointer anywhere the array has decayed.

#include <stdio.h>

void inspect(int arr[]) {
    printf("inside function: sizeof(arr) = %zu\n", sizeof arr);
    printf("inside function: computed length = %zu  <-- WRONG\n",
           sizeof arr / sizeof arr[0]);
}

int main(void) {
    int data[10] = {0};

    printf("in main: sizeof(data) = %zu\n", sizeof data);
    printf("in main: length = %zu  <-- correct\n",
           sizeof data / sizeof data[0]);

    inspect(data);
    return 0;
}

In main, sizeof data is 40 bytes and the length computes to 10. Inside inspect, sizeof arr is the size of a pointer - 8 on a 64-bit machine - and the "length" comes out as 2. The code looks identical and is quietly wrong.

The rule that follows: compute an array's length only in the scope where the array was declared, and pass it along from there.

& of an Array Is Not the Same Type

The other place decay does not happen is the & operator. &arr is a pointer to the whole array, not to its first element. Both hold the same address; the difference is what "add 1" means.

#include <stdio.h>

int main(void) {
    int arr[5] = {1, 2, 3, 4, 5};

    printf("arr      = %p   arr + 1  = %p\n",
           (void *)arr, (void *)(arr + 1));      // steps 4 bytes (one int)
    printf("&arr     = %p   &arr + 1 = %p\n",
           (void *)&arr, (void *)(&arr + 1));    // steps 20 bytes (the array)

    return 0;
}

Same starting address, different stride. arr has type int * and steps by one element; &arr has type int (*)[5] and steps by the entire array. This is the mechanism that makes passing a row of a 2D array work, which is covered in multidimensional arrays.

Pointer to Array vs Array of Pointers

Two declarations that look alike and mean opposite things:

int *p[5];     // array of 5 pointers to int
int (*q)[5];   // pointer to an array of 5 ints

[] has higher precedence than *, so int *p[5] parses as "p is an array, of pointers". The parentheses in int (*q)[5] force * to bind first: "q is a pointer, to an array".

int *p[5]                     int (*q)[5]

 p[0] -> [ int ]               q -> [ int | int | int | int | int ]
 p[1] -> [ int ]                     one contiguous block of 5
 p[2] -> [ int ]
 p[3] -> [ int ]
 p[4] -> [ int ]
 five separate addresses

An array of pointers is the common one, and you have already used it: char *argv[] is an array of pointers to strings, one per command-line argument. It is also how you hold a list of strings of different lengths without wasting space.

#include <stdio.h>

int main(void) {
    // array of pointers: each entry points to a string of its own length
    const char *days[] = {"Monday", "Tuesday", "Wednesday"};
    int n = sizeof days / sizeof days[0];

    for (int i = 0; i < n; i++) {
        printf("%d: %s\n", i, days[i]);
    }

    // pointer to an array of 5 ints
    int block[5] = {1, 2, 3, 4, 5};
    int (*q)[5] = &block;

    printf("via q: %d %d\n", (*q)[0], (*q)[4]);
    printf("sizeof(*q) = %zu bytes (the whole array)\n", sizeof *q);

    return 0;
}

Note (*q)[0]: dereference the pointer to get the array, then index it. The parentheses are required again, for the same precedence reason.

Where Arrays and Pointers Genuinely Differ

Keep this short table in mind and the confusion disappears:

An array name is not a variable holding an address - it is the storage, and the address is computed on demand. That is why you cannot assign to it.