How does passing an array to another C function work?

Why do I want a pointer to the initial array and not just the array itself?

That's because you cannot pass an array to a function. An array is not a first-class object in C unlike int, float, struct etc. This means an array is not copied to the function parameter. What actually gets passed is a pointer to the first element of the array. Therefore, the function parameter should be a pointer to the array element type. Also, you have to pass the length of the array to function as well since that information cannot be had in the function from the pointer that is passed to it.

An array is a different type than a pointer. There are some cases when it decays or is implicitly converted to a pointer to its first element. Therefore, your function should have the prototype

void saveArray(int *arr, int len);
// or 
void saveArray(int arr[], int len);

// in main, for example
int arr[6];
saveArray(arr, sizeof arr);
// equivalent to
saveArray(&arr[0], sizeof arr);

What does &arr even represent?

The address of operator & evaluates the address of its operand which must be an lvalue. Here arr is of type int[6], i.e., an array of 6 integers. Therefore &arr is of type int (*)[6], i.e., a pointer to an array of 6 integers. Please note that the value &arr is equal to the base address of the array but its type is not int *. It is a different type and has different pointer arithmetic. This is, in fact, one of the cases where an array does not decay into a pointer to its first element.

Yes

void saveArray(int *arr)

But for it to be useful, pass the array length too.

void saveArray(int *arr, int len)

Otherwise how will you know how long it is?

Call then like so:

saveArray(arr, 6);

The question "Would it be void saveArray(int *arr) or void saveArray (int arr)?" has already been answered. I am going to answer the question "What does &arr even represent?"

In your case, &arr has the same numerical value as &arr[0]. However, if you did something a bit different,

int* arr = malloc(sizeof(int)*6);

Then the numerical value of &arr will be different than that of &arr[0] even though you will be able to call saveArray(arr) without any difference in meaning for both cases.

In the first case, both &arr and &arr[0] are addresses on the stack.

In the second case, &arr is an address on the stack while &arr[0] is an address in the heap.

Hope that helps.

If you use this prototype:

void saveArray(int *arr)

you loose information about the array length (e.g. number of elements).

Unless your function is supposed to operate on arrays with fixed length (e.g. some functions doing 3D math calculations may just consider 3D vectors, with fixed size of 3 double elements), you should specify the array length (e.g. element count) as an additional parameter:

void saveArray(int * arr, int count);

If your function just observes the content of the input array and does not modify it, you can use const to make your code const-correct and more precise:

void saveArray(const int * arr, int count);

Sometimes size_t is used as a type to specify length/count parameters:

void saveArray(const int * arr, size_t count);

About the other option you listed in your question:

void saveArray(int arr)

That is wrong, since in this case arr is just a single integer (not an array). Instead, in the first (correct) case of passing [const] int*, you passed the address of the first item in the array, and since the array elements are stored in contiguous memory locations, just the address of the first item and the item count define the whole array.

At the call site, you can call your function like this:

int arr[<<some size here>>];
...
saveArray(arr, <<same size as above>>);

Or if you already have a pointer (e.g. since you allocated the array using malloc()), you can just specify the pointer itself:

int* arr;
arr = malloc( numberOfElements * sizeof(int) );
...
saveArray(arr, numberOfElements);