C++ Need explaination for this functions

Question

When I was programming in C++ today I noticed this phenomenon:

int main()
{
    int a = 42;
    func (a);

    cout << a << endl;
}

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

And of course the output was 42. Otherwise to get 5 as output i can rewrite the function using the address:

void func (int &x)
{
    x = 5;
}

This is what I understand, but when I did this:

int main()
{
    int a[2][2] = { {2,2}, {2,2} };
    func (a);

    cout << a[1][2] << endl;
}

void func (int x[2][2])
{
    x[1][2] = 5;
}

The output actually was 5, but for me this is unexplainable. Why should func affect any variables of main? Just because it's a 2d-Array?

Answer 1

Otherwise to get 5 as output i can rewrite the function using the address:

void func (int &x)
{
    x = 5;
}

There is no "address" here. x is a reference. Don't confuse references and pointers; they are quite different things.

void func (int x[2][2])

This is an attempt at passing an array to a function. What happens really is that you pass a pointer. The array which you pass is said to "decay" to a pointer to the array's first element (losing all size information).

It's as if you had written your function with a lovely parameter type like this:

void func(int (*x)[2])
{
    x[1][2] = 5;
}

What's confusing here is the fact that you've used a 2-dimensional array. The second dimension's size is actually preserved in the type. You could pass x[1] again to a function like void func2(int y[2]), and it would decay to a simple int*.

Nevertheless, the point is that you have not passed a reference but a pointer. The pointer itself is passed by value - but the pointer is used to indirectly modify the array in main.

Note that it is possible to pass arrays by reference. Here's how:

void func(int (&x)[2][2])

---

Conclusion:

• You need to understand the difference between references and pointers.
• An attempt to pass an array by value makes it "decay" to a pointer to its first element.
• It is possible to pass arrays by reference, even though the syntax is ugly.
• Two-dimensional arrays serve only to make the first three rules appear more complicated than they really are.
• Use std::vector / std::array instead of raw arrays.

Answer 2

First of all this function declaration

void func (int x[2][2])
{
    x[1][2] = 5;
}

is equivalent to

void func (int x[][2])
{
    x[1][2] = 5;
}

and in turn is equivalent to

void func (int ( *x )[2])
{
    x[1][2] = 5;
}

that is the parameter has type of pointer to one-dimensional array of type int[2]. The function has gotten an address of a memory.

When you call the function the following way

func (a);

array a is implicitly converted to pointer to its first "row" (first element).

So the function deals with a pointer. It does not change the pointer itself. It changes thye memory pointed to by this pointer.

Within the function body expression expression

x[1]

is equivalent to *( a + 1 ) and yields the second "row" of the array a (indices starts from 0).Let's name it row

Expression

x[1][2]

is equivalent to row[2] and yields reference to the third element of this row.

The value in this cell of the memory occupied by the array is changed in the function. That is the function does not deal with a copy of the value in this cell. It deals directly with the cell itself because we provided its address.

Take into acccount that this statement

cout << a[1][2] << endl;

is wrong. The valid range of indices for array a declared like

int a[2][2]

is [0, 1].

So you are trying to override memory beyond the array.

Answer 3

This is called Decay.
Arrays decay into raw pointers when passed as parameters.

for the compiler, the decleration

void func (int x[2][2]); 

is the same as

void func (int* x[2]);

thus the array is sent as a pointer to the first element and the function can change the original array.