Pass array to a function as a pointer and value

Question

What is the deference between passing array this way:

static char arr[N];

void func(void *buf, size_t size) {
    // ...
}

int main(void) {
    func(arr, N);

    // ...
}

And this way:

// ...

int main(void) {
    func(&arr, N);

    // ...
}

Is there any deference in those listings? It seems that the 2nd version passes an array as void **, but is it really so?

Due to [array to pointer decay](https://stackoverflow.com/q/1461432/12149471), `func(arr, N);` is equivalent to `func(&arr[0], N);`, i.e. you are passing a pointer to the first element of the array. In the second example, you are passing a pointer to the entire array, not to a single element. In C, both are possible, but it is generally easier to work with pointers to the first element of the array, instead of pointers to an entire array. — Andreas Wenzel, Dec 23 '22 at 09:00

Lundin · Accepted Answer · 2022-12-23T08:55:17.990

The first is correct and the second is wrong or at least very questionable.

arr when used in an expression or passed to a function, gets adjusted to a pointer to the first element. So it turns equivalent to char*.

In the second example, &arr is one of the few exceptions to this "array decay" rule. Instead of a pointer to the first element, we get a pointer to the whole array, type char(*)[N]. This type is not compatible with char*, so if you would attempt to cast the void* buf to a char* inside the function, the second example causes a subtle bug.

The reason why the second example compiles at all is because void* (and only that type, not void**) is a special pointer type that can be converted to/from any other pointer to object. Should you change the function to

void func(char *buf, size_t size)

Then func(&arr, N); gives the expected compiler diagnostic "passing argument 1 of 'func' from incompatible pointer type".

Now as it happens, if you write the function like this

void func(void *buf, size_t size) {
    char* ptr = buf;
    for(int i=0; i<size; i++)
    {
      printf("%c ", ch[i]);
    }
}

It will most likely work for either version, because the address of the first item (char*) is the same as the address of the array (char(*)[N]). Also, C's peculiar type system allows us to access a memory location of some type through an array or struct of items of that same type ("the strict aliasing rule").

Best practices:

Use the first version.
Avoid the use of void* when possible, since they are type unsafe.
Be as explicit with types as you can and don't rely on implicit type conversions.

Pass array to a function as a pointer and value

1 Answers1