Passing an Array by reference in C

by

This is caused by the fact that arrays tend to decay into pointers.

int a[] = { 1, 2, 3 };
int* p = a; // valid: p is now the address of a[0]
a = p;  // NOT valid.

printf("a = %p\n", a);
printf("p = %p\n", p); // prints same address as a

a and p will print the same value.

Contrary to what others have said, a is not a pointer, it can simply decay to one. http://c-faq.com/aryptr/aryptrequiv.html

In your first function() what gets passed is the address of the array’s first element, and the function body dereferences that. Infact, the compiler is treating the function prototype as this:

void function(int* array /*you wrote int array[]*/){
    array[0] = 4;
    array[1] = 5;
    array[2] = 6;   
}

function(&array[0]);

This has to happen because you said “array of unknown size” (int array[]). The compiler could not guarantee to deduce the amount of stack required to pass by value, so it decays to a pointer.

—- Edit —-

Lets combine both your examples and use more distinctive names to make things clearer.

#include <stdio.h>

void func1(int dynArray[]) {
    printf("func1: dynArray = %p, &dynArray[0] = %p, dynArray[0] = %d\n",
             dynArray, &dynArray[0], dynArray[0]);
}

void func2(int* intPtr) {
    printf("func2: intPtr = %p, &intPtr[0] = %p, intPtr[0] = %d\n",
             intPtr, &intPtr[0], intPtr[0]);
}

void func3(int intVal) {
    printf("func3: intVal = %d, &intValue = %p\n",
             intVal, &intVal);
}

int main() {
    int mainArray[3] = { 1, 2, 3 };
    int mainInt = 10;

    printf("mainArray = %p, &mainArray[0] = %p, mainArray[0] = %d\n",
             mainArray, &mainArray, mainArray[0]);
    func1(mainArray);
    func2(mainArray);

    printf("mainInt = %d, &mainInt = %p\n",
             mainInt, &mainInt);
    func3(mainInt);

    return 0;
}

Live demo at ideone: http://ideone.com/P8C1f4

mainArray = 0xbf806ad4, &mainArray[0] = 0xbf806ad4, mainArray[0] = 1
func1: dynArray = 0xbf806ad4, &dynArray[0] = 0xbf806ad4, dynArray[0] = 1
func2: intPtr = 0xbf806ad4, &intPtr[0] = 0xbf806ad4, intPtr[0] = 1

mainInt = 10, &mainInt = 0xbf806acc
func3: intVal = 10, &intValue = 0xbf806ad0

In func1 and func2 “dynArray” and “intPtr” are local variables, but they are pointer variables into which they receive the address of “mainArray” from main.

This behavior is specific to arrays. If you were to put the array inside a struct, then you would be able to pass it by value.

More Related Contents:

  1. Why isn’t the size of an array parameter the same as within main?
  2. C sizeof a passed array [duplicate]
  3. Passing an array as an argument to a function in C
  4. Difference between passing array and array pointer into function in C
  5. Why does a C-Array have a wrong sizeof() value when it’s passed to a function? [duplicate]
  6. Allocate memory 2d array in function C
  7. Pass an array to a function by value
  8. Returning Arrays/Pointers from a function
  9. Why use an asterisk “[*]” instead of an integer for a VLA array parameter of a function?
  10. Changing array inside function in C
  11. When is an array name or a function name ‘converted’ into a pointer ? (in C)
  12. How can I return a character array from a function in C?
  13. Manipulate multidimensional array in a function
  14. Pass by reference in C
  15. How can I malloc a struct array inside a function? Code works otherwise
  16. C pointer notation compared to array notation: When passing to function
  17. How can I check if an element in an array is equal to something in C? [closed]
  18. In C, are arrays pointers or used as pointers?
  19. Map a 2D array onto a 1D array
  20. Difference between char *str=”STRING” and char str[] = “STRING”?
  21. C programming, why does this large array declaration produce a segmentation fault?
  22. Weird behavior when printing array in C?
  23. Convert char array to a int number in C
  24. Reading numbers from a text file into an array in C
  25. Why can’t I treat an array like a pointer in C?
  26. Why is 248×248 the maximum bi dimensional array size I can declare?
  27. How to calculate size of array from pointer variable?
  28. Pointer to array of unspecified size “(*p)[]” illegal in C++ but legal in C
  29. array of pointers as function parameter
  30. Declaring an array of negative length

Leave a Comment