Pass and modify single row of a 2D array in C

Question

First of all I'm not confident with C, but I have a 2D array of int and I want a function to write all the values of a single line of this array.

For example:

int main(int argc, char *argv[])
{ 
    int a[2][2];
    a[0][0] = 1;
    a[0][1] = 2;
    a[1][0] = 3;
    a[1][1] = 4;
    change_array(&a[0]);
}

void change_array(int* array[])
{
    (*array)[0] = -1; 
    (*array)[1] = -1;        
}

The program crash immediately. I tried to change the change_array function to array[0] = -1 and... it works! Values are changed correctly (and I don't know why because it should be totally wrong), but if I use this function in other part of the program the values of array remain unchanged. How it could be possible? Any suggestion to successfully change the values of my array? Thank you very much!

Answer 1

You can try to do it like this:

#include <stdio.h>

void change_array(int array[2][2])
{
    array[0][0] = -1;
    array[0][1] = -1;
}

int main(int argc, char *argv[])
{
    int a[2][2];
    a[0][0] = 1;
    a[0][1] = 2;
    a[1][0] = 3;
    a[1][1] = 4;
    printf("%d %d\n%d %d\n\n", a[0][0], a[0][1], a[1][0], a[1][1]);
    change_array(a);
    printf("%d %d\n%d %d\n\n", a[0][0], a[0][1], a[1][0], a[1][1]);
}

It depends on your needs, but in some cases I have found that it is better to use a single-diemensional array and build a getter/setter for 2 diemensions. Such solution can be found in this answer: Correct way to allocate and free arrays of pointers to arrays

Answer 2

Your code passes something to change_array that is different from the parameter declared for change_array.

In the code change_array(&a[0]), a is an array of two arrays of two int. So a[0] is the first array of two int. So &a[0] is the address of the first array of two int. Compare this with the declaration of change_array. In void change_array(int* array[]), array is an array of pointers to int. So that is a different type.

Instead, you could declare change_array with void change_array(int (*array)[]). Then array is a pointer to an array of int, and your code would work (using (*array)[0] = -1).

Note: You should compile with warnings enabled, and preferably with strict or pedantic language semantics. Then the compiler should have warned you that change_array is used in main without a prior declaration. You should have a prior declaration, so that the compiler knows the full type of change_array before it is used. With that, the compiler would have seen that the wrong type was passed, and it would warn you.

Although the above would correct your code, most people would use a different solution. They would declare change_array with void change_array(int *array), and they would call it with change_array(a[0]).

In change_array(a[0]), a[0] is the first array of two int. However, there is a rule in the C language that an array expression is converted to a pointer to its first element. So a[0] automatically becomes &a[0][0]. (This conversion occurs whenever the array is not the operand of &, sizeof, or _Alignof and is not a string literal used to initialize an array.) So the call is passing a pointer to int, which matches the parameter that is a pointer to int. Then the parameter array can be used as array[i] to access array elements, so you can use the simpler syntax array[0] = -1 instead of (*array)[0] = -1.

Answer 3

In C, an array variable decays into a pointer to the memory address that contains the first element of the array, when it is passed as a parameter to a function. That is joined to the fact that all it's elements are placed in contigous memory. So C only needs to save the first position of the array (no matter how many dimensions it has) and will then be able to calculate, based on the indexes, what offset of the pointed memory it should access.

So, on your particular piece of code variable a points to the first element, which is a[0][0]. So, basically doing this:

change_array(&a[0]);

Is roughly (but not exactly) the same as doing:

change_array(a);

Now, knowing how arrays are passed in C, you should be able to deduce that, indeed, two dimensional arrays, when passed as parameters, actually contain on the access to their first coordinate a pointer to where the first element of the second coordinate is. So, when you do array[0] you're passing a pointer to the first element of the array under the first coordinate. and then when you do *(array[0]) you're actually accessing the first element of the second coordinate.

Here it is also important to add then that; since array variables decay into pointers, then all arrays in C are passed by reference, because you are passing a pointer. So all function calls that modify an array passed to them will do actual modifications.

Knowing this, then your function should be:

void change_array(int *array)
{
    array[0] = -1;
    array[1] = -1;
}

And then you can perform a call such as:

change_array(a[0]);

In order to modify the elements of the first array of a.

Now, as good practice in C, and in order to avoid segmentation faults, one would pass to the function along with the pointer, an integer saying the size of the array:

void change_array(int *array, int size);

And then always perform the access checking this bound.