Passing Arrays to Functions with Pointers

The Illusion of Passing an Array

When you pass an array to a function in C, it looks like you're passing the entire array. But what happens under the hood is different and far more efficient. Let's start with a classic experiment that reveals the truth.

As the video demonstrates, sizeof gives the expected size of the whole array (e.g., 20 bytes for 5 integers) in main, but it returns the size of a single pointer (e.g., 4 or 8 bytes) inside the function. This discrepancy is the key to understanding how arrays are passed.

Array Name "Decay"

The behavior you just saw is due to a fundamental rule in C called array decay. When an array name is used in most expressions—including passing it to a function—it "decays" into a pointer to its first element.

The C Standard is very specific about this. For a deeper, formal explanation, the C-FAQ is an invaluable resource.

Because of this decay, a function never receives a full copy of an array. It only receives the starting address. This has three crucial consequences:

1. Efficiency: Copying a large array onto the stack would be slow and could cause a stack overflow. Passing a single pointer is extremely fast and memory-efficient. In your work with ADAS, where you might handle large data buffers from cameras or RADARs, this principle is what makes processing that data feasible without massive overhead.
2. Loss of Size Information: Since the function only gets a pointer, it has no information about the original array's size. This is why the sizeof trick failed. You must always pass the size of the array as a separate argument.
3. Ability to Modify: The function now has a pointer to the original data. This means it can modify the elements of the caller's array directly. This is not pass-by-value; it's an effective simulation of pass-by-reference.

Let's see how the mycodeschool video explains this mechanism.

As the video and C-FAQ confirm, within the context of a function parameter list, the following declarations are 100% equivalent to the compiler:
void my_func(int arr[100]);
void my_func(int arr[]);
void my_func(int *arr);

All three declare arr as a pointer to an integer (int*). The array-like syntax [] is just "syntactic sugar" to make the function's intent clearer to human readers.

To see the modification aspect in action, the final part of the video demonstrates a function that doubles each element in the original array.

#include <stdio.h>

void clear_flags(unsigned char *flags) {
    // There is a bug on the next line.
    size_t num_flags = sizeof(flags) / sizeof(flags[0]); 
    
    for (size_t i = 0; i < num_flags; ++i) {
        flags[i] = 0;
    }
}

int main() {
    unsigned char error_flags[16] = {1, 1, 0, 1, /* ...and so on */};
    
    clear_flags(error_flags);
    
    // Check if the first flag is cleared
    if (error_flags[0] == 0) {
        printf("First flag cleared.\n");
    } else {
        printf("First flag NOT cleared. Value: %u\n", error_flags[0]);
    }
    
    return 0;
}

Passing Multi-Dimensional Arrays

This is where many developers get tripped up. Given that a 1D array decays to a pointer, it's a common but incorrect assumption that a 2D array int arr[3][4] decays to a pointer-to-a-pointer (int**).

A 2D array is an "array of arrays". So, an array of [array of 4 ints] decays to a pointer to an [array of 4 ints].

The syntax for this is int (*p)[4]. This declares p as a pointer to an array of 4 integers.

This distinction is vital because the compiler needs to know the size of all dimensions except the first to calculate memory offsets. To access arr[i][j], the compiler computes the address: base_address + (i * NUM_COLUMNS + j) * sizeof(element). Without NUM_COLUMNS, this calculation is impossible.

Let's see this explained visually.

This leads to the correct function signatures for a 2D array int arr[ROWS][COLS]:
void my_func(int arr[ROWS][COLS]);
void my_func(int arr[][COLS]);
void my_func(int (*arr)[COLS]);

Again, all three are equivalent. Notice that the number of columns (COLS) must be specified. Only the first dimension (ROWS) can be omitted.

The C-FAQ provides the definitive textual explanation for this rule.

In your work with AUTOSAR, if you were to define a software component that processes a signal group represented as a 2D array in an ARXML file, the generated RTE (Runtime Environment) function stub would follow these rules precisely, creating a function signature with a pointer to an array of a fixed size.

Conclusion

You've now seen how C handles passing arrays to functions—a design choice that prioritizes performance and memory efficiency by passing pointers instead of making copies.

Key Takeaways:

• Array Decay: When passed to a function, an array name "decays" into a pointer to its first element.
• Efficiency: This mechanism avoids copying large amounts of data, which is critical for performance-sensitive applications like those in automotive systems.
• Pass the Size: Because the function only receives a pointer, it loses size information. You must always pass the array's size as a separate parameter.
• Modification: The function receives a pointer to the original data and can therefore modify the caller's array.
• Multi-Dimensional Arrays: A 2D array T arr[R][C] decays to a pointer to an array, T (*p)[C]. All dimensions except the first must be specified in the function parameter so the compiler can perform address arithmetic.

In our next lesson, we will leverage the modification capability we explored today to solve a common C problem: how to use pointer parameters to return multiple values from a function.