C modifying array unexpected behaviour

Question

I understand it is not possible to pass an array to a function in C and modify it without using sending a reference to that array, so how is the chess method initialising the array, and it is being printed correctly in main?

int chess(int rows, int cols, int array[rows][cols])
{

  /* Go through the rows and colums in the array */
  for (int i = 0; i < rows;i++)
  {

    for (int j = 0; j < cols; j++)
    {
      /* If the location is even, then print a 0, else print a 1. */
      if (((i + j) % 2) ==0)
      {
        array[i][j] = 0;
      }
      else
      {
        array[i][j] = 1;
      }
    }
  }
  /* return */
  return 0;

}

int main(void)
{
  int arrayDimensions;

  int noOfTests = 7;

  /* run the program for the given amount of tests */
  /*for (arrayDimensions = 0; arrayDimensions <= noOfTests; arrayDimensions++)*/
  {
    /* Declare an array for each dimension */
    int array[6][5];

    /* call the chess method passing it the arguments specified. */
    chess(6, 5, array);

    /* Print out the array according to the size of the array. */
    for (int i = 0; i < 6; i++)
    {
      printf("\n");
      for (int j = 0; j < 5; j++)
      {
        printf("%d", array[i][j]);
      }

    }
    /* Create a new line after each row */
    printf("\n");

  }

}

score 3 · Accepted Answer · edited May 23 '17 at 12:13

Though you probably already know most of this, the latter part is relevant, so stay with this for a moment.

What you probably know

C is a pass-by-value language. This means when you do this:

void foo(int x)
{
    x = 5;
}

called as

int n = 1;
foo(n);
printf("%d\n", n); // n is still 1

the caller passes a value and the parameter x receives it. But changing x has no effect on the caller. If you want to modify a caller's data variable, you must do so by-address. You do this by declaring the formal parameter to be a pointer-to-type, dereference the pointer to modify the pointed-to data, and finally, pass the address of the variable to modify:

void foo(int *p)
{
    *p = 5;
}

called as:

int n = 1;
foo(&n);
printf("%d\n", n); // n is now 5

Why do you care?

So what does any of this have to do with your array? Arrays in C are a contiguous sequence of data of the underlying type of the array, and an array's expression value is the address of its first element.

Chew on that last sentence for a minute. That means the same way an int variable has a value of the int stored within, an array variables has the address of its first element as its "value". By now you know that pointers hold addresses. Knowing that and the previous description means this:

int ar[10];
int *p = ar;

is legal. The "value" of ar is its first-element address, and we're assigning that address to p, a pointer.

Ok then, So the language specifically defined arrays as parameters as simply pointers to their first elements. Therefore both of these are equivalent:

void foo(int *p)
{
    *p = 5;
}

void bar(int ar[])
{
    ar[0] = 5;
}

And the caller side:

int ar[10];
foo(ar); // legal, ar's "value" is its first element address
bar(ar); // legal, identical to the above.

A phrase I often use when explaining the fundamentals of pointers and arrays is simply this:

A pointer is a variable that holds an address; an array is a variable that is an address.

So whats with this whacky syntax?

int chess(int rows, int cols, int array[rows][cols])

Ah. There is something interesting. Your compiler supports VLA s (variable length arrays). When compiling the code for this function the compiler generates the proper logic to perform the proper access to the passed array. I.e. it knows that this:

array[1][0]

is cols many int values past the beginning of the array. Without the feature of VLAs (and some C compilers don't have them), you would have to do this row-by-column math yourself by hand. Not impossible, but tedious none-the-lesss. And i only briefly mention that C++ doesn't support VLA's; one of the few features C has that C++ does not.

Summary

Arrays are passed by address because when it comes to their "value", that is all they really are: an address.

Note: I worked very hard to avoid using the word "decay" or the phrase "decays to a pointer" in this description precisely because that verb implies some mystical functional operation when in-fact none exists. Arrays don't "decay" to anything. They simply are; Their "value", per the C standard, is the address of their first element. Period. What you do with that address is another matter. And as an address, a pointer can hold their "value" and dereference to access said-same (such as a function parameter).

Personal: I once asked on this forum how long that term (decay) has been buzzed about in C-engineer vernacular, since in the 600+ pages of the C standard it appears exactly ZERO times. The farthest back anyone found was 1988 in the annals of some conspicuous online journal. I'm always curious to note who started it an where, and said-quest continues to elude me.

Anyway, I hope this helps, even a little.

nice work, except where you say "a phrase I often coin..." as you can only *coin* a phrase once ;) — RobP, Apr 08 '14 at 21:23
+1 for clear explanation *and* caring about the linguistic usage! — RobP, Apr 08 '14 at 22:38

score 1 · Answer 2 · answered Apr 08 '14 at 20:30

when dealing with arrays you are dealing with an address so if you pass an array into a function and you changed the array in the function, the real array will change. In other words, if you know pointers an array is a pointer. I didn't read the code but you have a clear misunderstanding of passing an array to a function.

score 0 · Answer 3 · answered Apr 08 '14 at 20:32

An array reference IS an address (it's a misnomer to say it's a pointer, but it will behave as such). It works because the function is declared to accept a type of int[][], which allows the function to interact with the array reference as if you'd passed a pointer to the function.

score 0 · Answer 4 · answered Apr 08 '14 at 20:32

From a reference manual:

When a function parameter is declared as an array, the compiler treats the declaration as a pointer to the first element of the array. For example, if x is a parameter and is intended to represent an array of integers, it can be declared as any one of the following declarations:

int x[]; int *x; int x[10];

So you are passing a reference. The compiler turns your declaration into a pointer reference with also some sizing constraints.

I wouldn't use the phrase pass a reference. You are passing an array which decays to a pointer. — this, Apr 08 '14 at 20:39

C modifying array unexpected behaviour

4 Answers4