Removing an array (row) from a 2d array - C Programming

Question

Lets say I have a 2d array:

int array[3][3];

with

000
111
222

and I want to remove 000.

I wrote a function:

void remove(int (*array)[3], int index, int array_length)
{
   int i;
   for(i = index; i < array_length - 1; i++)
   {
       array[i] = array[i + 1];
   } 
}

which receives pointer to the first element of the 2d array, index which I want to remove and a length of the array.

In the for loop, I move array at the position index to the next element.

But I receive this error message:

error: assignment to expression with array type

array[i] = array[i + 1];

Why?

How can I remove element and get the 2d array without array at the index? Should I maybe make new 2d array and return it instead of passing pointer of 2d array to the function?

Answer 1

You can do what you originally wanted if you use an array of structs instead of a 2D array.

The C language treats structs as value types so you can copy them with simple and safe assignment (no memcpy needed).

Here's an example with a few tweaks.

//try online here: https://rextester.com/DDHBC95444
#include  <stdio.h>

//from Chromium code https://stackoverflow.com/a/1598827/7331858
#define COUNT_OF(x) ((sizeof(x)/sizeof(0[x])) / ((size_t)(!(sizeof(x) % sizeof(0[x])))))

typedef struct row_t {
    int columns[3];
} row_t;

void remove_row(row_t * const rows, const size_t row_index, const size_t row_count)
{
   for (size_t i = row_index; i < row_count - 1; i++) {
       rows[i] = rows[i + 1];
   }
}

void print_rows(row_t const * const rows, const size_t row_count)
{
   const size_t column_count = COUNT_OF(rows[0].columns);

   for (size_t r = 0; r < row_count; r++) {
       for (size_t c = 0; c < column_count; c++) {
           printf("%02i ", rows[r].columns[c]);
       }
       printf("\n");
   }
}

int main(void)
{
    row_t rows[] = { {{0,1,2}}, {{10,11,12}}, {{20,21,22}} };
    print_rows(rows, COUNT_OF(rows));

    printf("\n'removing' row index 1\n");
    remove_row(rows, 1, COUNT_OF(rows));
    print_rows(rows, COUNT_OF(rows));

    return 0;
}

outputs:

00 01 02 
10 11 12 
20 21 22 

'removing' row index 1
00 01 02 
20 21 22 
20 21 22 

Answer 2

The parameter array is declared as int (*array)[3], so its type is pointer to an array of 3 ints. The type of array[i] is array of int and an array cannot be assigned to. A function to shift the rows of your matrix can be implemented like this:

void remove(int (*array)[3], int index, int array_length)
{
   int i, j;
   for(i = index; i < array_length - 1; i++) {
       for (j = 0; j < 3; ++j)
           array[i][j] = array[i + 1][j];
   } 
}

Note that the function does not really remove the row, just shifts the rows up. So its name is misleading. You must create a new array and copy the old array to the new array except the indicated row to really remove a row and to change the dimensions of the array.

Edit: The name of that function should be changed because the standard library already has a function named remove.

If the array is obtained like that:

int (*array)[3] = malloc(array_length * sizeof *array);

You can shrink the array by calling the realloc:

int (*p)[3] = realloc(array, (array_length - 1) * sizeof *p);
if (p != NULL)
    array = p;

Answer 3

int (*array)[3] -> Here, array is a pointer to 3 element integer array.

error: assignment to expression with array type

This is because an array variable is not modifiable/re-assignable like a pointer. Operations that can be performed on an lvalue of array type are: sizeof, unary & and implicit conversion to pointer type.

Answer 4

The error is telling you that C doesn't support array assigning. Your code tries to copy the whole line i + 1 into the line i of the matrix, but C doesn't know how to operate this.

The solution is to iterate through each element of your array, copying one by one.

void remove(int (*array)[3], int index, int array_length)
{
   int i, j;
   for(i = index; i < array_length - 1; i++)
   {
       for(j = 0; j < array_length; ++)
       {
           array[i][j] = array[i + 1][j];
       }
   } 
}

The code above assumes that your matrix is always squared, but you could change its dimension inside j's for loop.