Passing whole array to a function.

Question

when we pass an element of an array to a function, it is treated as an normal variable and the called function creates a copy of the actual argument and operates on it.Any changes made in the formal arguments doesn't affect the actual arguments.

But this not the case when we pass a whole array. In this case it(called function) gets access to the actual arguments and any changes made in the formal arguments affects the actual arguments. Why this happens ?

Answer 1

The array is passed as a pointer to the elements.

If I write:

void doStuff(int *ptr)
{
  ptr[1] = 5;
}

int main()
{
  int arr[] = {0, 1, 2};
  doStuff(arr);
  printf("%d %d %d\n", arr[0], arr[1], arr[2]);
}

the output will be "0 5 2". That's because C passes whatever is actually the parameter by value. The parameter is a pointer to an int. So a pointer to an int is passed by value. Thus, doStuff gets a copy of a pointer to memory in main's stack frame. When it dereferences that pointer with ptr[1], it is following the pointer to main's memory and modifying the array there.

C can only pass by value, but it does so "shallowly". If you ask it to pass an int *, it will pass an int *. It only copies the value of the pointer, not the values of anything it points to.

If you want doStuff to get its own copy of the array, either wrap the array in a struct as others have suggested, or use memcpy to manually deep copy the array like this:

void doStuff(int *ptr, int nElems)
{
  int myCopyOfTheArray[nElems];
  memcpy(myCopyOfTheArray, ptr, sizeof(int) * nElems);
  /* do stuff with the local copy */
}

Unlike using a struct, the memcpy approach works if nElems is only know at runtime.

Answer 2

An array in C may be treated as a pointer to the first element of the array. The pointer is passed by-value (you cannot modify the value passed in), but you can dereference it and modify the memory that it points at.

Answer 3

Arrays can't be passed by value in C. They get demoted to pointers. So the called function sees a pointer to the array (passed by reference) and operates on it. If you want to make a copy, you have to either do so explicitly, or put your array inside a struct (which can be passed by value to functions.)

Answer 4

Because when You pass a whole array to function You pass a pointer to that array, which means that You give function a place in memory where this array is located. So when You change the array in function You are changing the original array as well.

Answer 5

It is expensive to make a copy of a whole array, in general. Back in the days when C was first created, it could easily exhaust the machine resources (stack in particular).

If you really want to pass an array, wrap it in a structure:

struct wrap { int array[100]; };

int somefunc(struct wrap large) { ... }

void anotherfunc(void)
{
    struct wrap a;
    ...add data to array...
    printf("%d\n", somefunc(a));
}

Answer 6

"Pass by reference" is a red herring in C. All arguments to a function are "passed by value" only. In case of arrays, you pass the address of the first element in the form of a pointer. You can then use this pointer to refer to the desired memory location & read or write values.

Answer 7

I haven't really seen any answers yet cover the whole question yet. From what I see, it looks like the question asks something like this:

Given the following code:

int a[5];

foo(a);
bar(a[0]);

Why can foo manipulate the original values while bar receives only a copy of the value being passed in?

This is because of the use of array notation: the [] operator dereferences the item it references in the array and passes in the value at that location.

So

int a[5];
bar(a[0]);

is different than:

int* a;
bar(a);

If you want to pass in a references to a specific item in an array, you need to use the & operator:

bar(&a[5]);