PREV_LEC NEXT_LEC

Prerequisites

You need pointer arithmetic, the relationship a[i] equals *(a + i), and the pointer parameter rules from the previous lecture. A host compiler such as GCC is enough to try every example.

What Is Array Decay in C?

In most expressions, the name of an array is converted into a pointer to its first element. The exceptions are sizeof, the unary &, and string-literal initialisers. A function call is not an exception, so the callee receives a pointer and has no idea how many elements are behind it.

Array Parameter sizeof: The Surprise

Here is the program that proves it. Save it as ep_array_param.c. It also demonstrates assigning to an array parameter, starting a scan at samples + 3, and a pointer-only bubble sort.

#include <stdio.h>

static void report(int buf[10])
{
    printf("inside : sizeof buf = %zu\n", sizeof buf);
}

static void rebind(int buf[10])
{
    int spare = 5;
    buf = &spare;                /* legal: buf is just a local pointer */
}

static void print_until(const int *p, int stop)
{
    for (int i = 0; p[i] != stop; i++)
        printf("%d ", p[i]);
    printf("\n");
}

static void swap_int(int *a, int *b)
{
    int t = *a;
    *a = *b;
    *b = t;
}

static void sort_ptr(int *base, int n)
{
    for (int i = 0; i < n - 1; i++)
        for (int j = 0; j < n - 1 - i; j++)
            if (*(base + j) > *(base + j + 1))
                swap_int(base + j, base + j + 1);
}

int main(void)
{
    int samples[10] = {90, 85, 70, 65, 60, 55, 40, 35, 30, 25};

    printf("outside: sizeof samples = %zu\n", sizeof samples);
    report(samples);

    rebind(samples);
    printf("samples[0] after rebind = %d\n", samples[0]);

    print_until(samples + 3, 40);

    sort_ptr(samples, 10);
    for (int i = 0; i < 10; i++)
        printf("%d ", samples[i]);
    printf("\n");
    return 0;
}

Build and Run

$ gcc -Wall -Wextra -std=c11 -o ep_array_param ep_array_param.c
ep_array_param.c: In function 'report':
ep_array_param.c:5:50: warning: 'sizeof' on array function parameter 'buf'
 will return size of 'int *' [-Wsizeof-array-argument]
$ ./ep_array_param
outside: sizeof samples = 40
inside : sizeof buf = 8
samples[0] after rebind = 90
65 60 55
25 30 35 40 55 60 65 70 85 90

GCC even warns that sizeof on the parameter returns the size of a pointer. On a 64-bit PC the pointer is 8 bytes. On a 32-bit Cortex-M it prints 4. Old 16-bit DOS compilers printed 2, which is why older textbooks show that number.

Reading the Output Line by Line

• 40 versus 8. Ten ints of 4 bytes each outside, one pointer inside.
• samples[0] stays 90. rebind pointed its own local pointer at a different variable. The caller’s array never changed.
• 65 60 55. We passed samples + 3, so the scan starts at element 3 (value 65) and stops when it sees 40, the sentinel.
• Sorted ascending. The bubble sort works through base directly, and the helper receives addresses of two elements.

Why You Cannot Assign to an Array

The rebind trick works for the parameter because the parameter is a pointer. A real array variable is different. Its name is not a modifiable lvalue, so this tiny file fails:

int main(void)
{
    int local_buf[10];
    int spare = 4;

    local_buf = &spare;          /* arrays are not assignable */
    return 0;
}

$ gcc -std=c11 -c ep_array_assign_err.c
ep_array_assign_err.c:6:15: error: assignment to expression with array type

Passing the Length Along

Because the callee cannot recover the size, every array-handling function needs the count as a separate parameter. The idiom is (const int *data, size_t n). In the caller, compute the count with sizeof arr / sizeof arr[0] while the name is still a real array.

Sentinels, such as stopping at the value 40 in print_until, are fragile. If the sentinel is absent, the loop walks off the end of the array. Use them only for data whose format guarantees a terminator, such as C strings.

Real-World Uses in Embedded Systems

• ADC sample buffers. A filter function takes (const uint16_t *samples, size_t n) and works the same for a 16-sample and a 1024-sample buffer.
• UART and SPI drivers. uart_write(const uint8_t *data, size_t len) is the standard shape. Passing buf + offset lets you send a tail of a buffer without copying.
• DMA descriptors. The driver stores a base pointer and a count, never an array.
• Sorting and median filters. A median-of-five filter often uses a small insertion sort over a pointer and a length.

Common Mistakes and Troubleshooting

Best Practices

• Declare array parameters as pointers, with const when read-only, and always pass a length.
• Use size_t for lengths and indices.
• Compute array length at the definition site with sizeof arr / sizeof arr[0], ideally inside an ARRAY_LEN macro.
• Keep swap helpers tiny and pointer-based, so they can be reused for any sort routine.
• Enable -Wsizeof-array-argument (part of -Wall in GCC) and never ignore it.

Performance and Security Considerations

Passing a pointer plus a length costs one or two registers regardless of array size, so large buffers never get copied on the way in. Bubble sort is O(n squared) and fine for a handful of samples, but use a better algorithm for hundreds. For security, the length must come from a trusted source. A length taken from a received packet without checking is the classic route to buffer overflows.

Suggested Images

Summary and Key Takeaways

Conclusion

Array decay is the reason C code is full of (pointer, length) pairs. Once you stop expecting the array to travel with its size, buffer-handling code becomes straightforward and far safer. Next we step up a dimension and see what the same decay rules mean for two- and three-dimensional arrays.

FAQ: Array Parameters in C

PREV_LEC NEXT_LEC