When you pass an array name as an argument to a function, what is actually being passed?

An array is a collection of values of the same data type, stored in contiguous memory locations. When an array name is passed as an argument to a function, the array's base address (the address of the first element) is passed. This means that the function receives a reference (or a pointer) to the original array in memory, and not a separate copy of the array values.

When an array name is passed to a function, it is typically done by specifying the array name without any brackets or indices. For example, if we have an array named "numbers" and a function named "processArray", the array can be passed as an argument like this: `processArray(numbers);`.

Once the array name has been passed to the function, the elements of the array can be accessed using pointer arithmetic or array notation. The function's parameter should be a pointer of the same data type as the elements of the array. For example, if the array has integer elements, the function's parameter should be an `int` pointer: `void processArray(int *arrayPtr)`. Within the function, individual elements of the array can be accessed using standard array notation with the pointer variable, e.g., `arrayPtr[i]`.

Since the function receives a reference to the original array, any changes made to the array elements within the function will affect the original array. This is because the function is working directly with the memory locations where the array elements are stored. For example, if we want to double each element of the passed array within the "processArray" function, we can do: ``` void processArray(int *arrayPtr, int arraySize) { for (int i = 0; i < arraySize; i++) { arrayPtr[i] = arrayPtr[i] * 2; } } ``` In this example, after calling the `processArray(numbers, 5)` function, the elements of the "numbers" array will be doubled, as the function directly modifies the memory locations of the array elements.