Resizing a 2D array of structures

I am trying to write a function resizeArray that resizes a 2D array array of my custom type cell and if not enough memory could be allocated returns an error message. However, my code does not work, but my compiler, strangely, does not throw a warning. It suspect that my returned pointer type of resizeArray is not fitting. Could you please tell me what I am doing wrong?

#include <stdio.h>
#include <stdlib.h>
typedef struct
{
int variable_1;
int variable_2;
char character;
} cell;
unsigned long max(unsigned long a, unsigned long b)
{
if (a >= b)
return a;
else
return b;
}
void initialiseArray(unsigned long rows, unsigned long columns,
cell array[rows][columns])
{
for (unsigned long i = 0; i < rows; i = i + 1)
for (unsigned long j = 0; j < columns; j = j + 1)
{
array[i][j].variable_1 = 0;
array[i][j].variable_2 = 0;
array[i][j].character = ' ';
}
}
cell *resizeArray(unsigned long rows, unsigned long columns,
unsigned long *array_rows, unsigned long *array_columns,
cell array[*array_rows][*array_columns])
{
if (rows > *array_rows || columns > *array_columns)
{
unsigned long new_array_rows = max(rows, *array_rows);
unsigned long new_array_columns = max(columns, *array_columns);
cell (*new_array)[new_array_rows][new_array_columns] = malloc(sizeof *new_array);
if (new_array == NULL)
{
printf("Error in ""resize"": Memory could not be allocated.\n");
return NULL;
}
else
free(array);
*array_rows = new_array_rows;
*array_columns = new_array_columns;
return new_array;
}
}
int main(void)
{
unsigned long array_rows = 10;
unsigned long array_columns = 15;
cell (*array)[array_rows][array_columns] = malloc(sizeof *array);
if (array == NULL)
{
printf("Error in ""main"": Memory could not be allocated.\n");
return 3;
}
cell *new_array = resizeArray(15, 15, &array_rows, &array_columns, *array);
if (new_array == NULL)
printf("Memory error. We stop the program.\n");
return -1;
array = new_array;
initialiseArray(array_rows, array_columns, *array);
return 0;
}

There are multiple problems in your code:

• in function main there are missing braces after the test for allocation failure, causing the rest of the code to be ignored. Write this:

    if (new_array == NULL) {
  printf("Memory error. We stop the program.\n");
  return 1;
  }
  

• function resizeArray does not return anything in case the array does not need to be reallocated. You should add return &array[0][0]; at the end of the function.

• in the same function, return new_array; is a type mismatch. You could silence the warning with return (void *)new_array; or return the appropriate type return &(*new_array)[0][0];

• in main, the same problem when storing array = new_array;. You can simply write array = (void *)new_array; as there is no easy way to express the appropriate cast.

Note however that your approach is confusing and error prone: the last call initialiseArray(array_rows, array_columns, *array) passes *array as an array of array_columns columns and array_rows rows, which decays to a pointer to arrays of array_columns ints, but this is technically a type mismatch that is not caught by the compiler: the type of array still refers to the original values of array_columns and array_rows, not the current modified ones, so using *array inside main to refer to the cells of the reallocated array will fail.

Here is a modified version displaying the problem:

#include <stdio.h>
#include <stdlib.h>
typedef struct
{
int variable_1;
int variable_2;
char character;
} cell;
unsigned long max(unsigned long a, unsigned long b)
{
if (a >= b)
return a;
else
return b;
}
void initialiseArray(unsigned long rows, unsigned long columns,
cell array[rows][columns])
{
for (unsigned long i = 0; i < rows; i = i + 1)
for (unsigned long j = 0; j < columns; j = j + 1)
{
array[i][j].variable_1 = i;
array[i][j].variable_2 = j;
array[i][j].character = ' ';
}
}
cell *resizeArray(unsigned long rows, unsigned long columns,
unsigned long *array_rows, unsigned long *array_columns,
cell array[*array_rows][*array_columns])
{
if (rows > *array_rows || columns > *array_columns)
{
unsigned long new_array_rows = max(rows, *array_rows);
unsigned long new_array_columns = max(columns, *array_columns);
cell (*new_array)[new_array_rows][new_array_columns] = malloc(sizeof *new_array);
if (new_array == NULL)
{
printf("Error in ""resize"": Memory could not be allocated.\n");
return NULL;
}
else
{
free(array);
}
*array_rows = new_array_rows;
*array_columns = new_array_columns;
return &(*new_array)[0][0];
}
return &array[0][0];
}
void displayArray(unsigned long rows, unsigned long columns, cell array[rows][columns])
{
for (unsigned long row = 0; row < rows; row++) {
for (unsigned long col = 0; col < columns; col++) {
cell c = array[row][col];
printf(" {%d,%d,'%c'},", c.variable_1, c.variable_2, c.character);
}
printf("\n");
}
}
int main(void)
{
unsigned long array_rows = 3;
unsigned long array_columns = 3;
cell (*array)[array_rows][array_columns] = malloc(sizeof *array);
if (array == NULL)
{
printf("Error in ""main"": Memory could not be allocated.\n");
return 3;
}
cell *new_array = resizeArray(4, 5, &array_rows, &array_columns, *array);
if (new_array == NULL) {
printf("Memory error. We stop the program.\n");
return -1;
}
array = (void *)new_array;
initialiseArray(array_rows, array_columns, *array);
printf("Using displayArray:\n");
displayArray(array_rows, array_columns, *array);
printf("Same code from main:\n");
for (unsigned long row = 0; row < array_rows; row++) {
for (unsigned long col = 0; col < array_columns; col++) {
cell c = (*array)[row][col];
printf(" {%d,%d,'%c'},", c.variable_1, c.variable_2, c.character);
}
printf("\n");
}
return 0;
}

Output:

Using displayArray:
{0,0,' '}, {0,1,' '}, {0,2,' '}, {0,3,' '}, {0,4,' '},
{1,0,' '}, {1,1,' '}, {1,2,' '}, {1,3,' '}, {1,4,' '},
{2,0,' '}, {2,1,' '}, {2,2,' '}, {2,3,' '}, {2,4,' '},
{3,0,' '}, {3,1,' '}, {3,2,' '}, {3,3,' '}, {3,4,' '},
Same code from main:
{0,0,' '}, {0,1,' '}, {0,2,' '}, {0,3,' '}, {0,4,' '},
{0,3,' '}, {0,4,' '}, {1,0,' '}, {1,1,' '}, {1,2,' '},
{1,1,' '}, {1,2,' '}, {1,3,' '}, {1,4,' '}, {2,0,' '},
{1,4,' '}, {2,0,' '}, {2,1,' '}, {2,2,' '}, {2,3,' '},

You might consider using 2D indirect addressing to manipulate dynamically sized matrixes. Here is a modified version using a single allocation per matrix:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
int variable_1;
int variable_2;
char character;
} cell;
size_t max(size_t a, size_t b)
{
if (a >= b)
return a;
else
return b;
}
cell **allocateArray(size_t rows, size_t cols)
{
/* allocate combined packed 2D matrix with an array of column pointers */
size_t head_size = (sizeof(cell **) * rows + sizeof(cell) - 1) / sizeof(cell);
cell **res = calloc(head_size + rows * cols, sizeof(cell));
if (res != NULL) {
for (size_t i = 0; i < rows; i++)
res[i] = (cell *)res + head_size + i * cols;
}
return res;
}
void initialiseArray(size_t rows, size_t columns, cell **array)
{
for (size_t i = 0; i < rows; i = i + 1) {
for (size_t j = 0; j < columns; j = j + 1) {
array[i][j].variable_1 = i;
array[i][j].variable_2 = j;
array[i][j].character = ' ';
}
}
}
cell **resizeArray(size_t rows, size_t columns,
size_t *array_rows, size_t *array_columns, cell ***arrayp)
{
cell **array = *arrayp;
if (rows > *array_rows || columns > *array_columns) {
size_t new_array_rows = max(rows, *array_rows);
size_t new_array_columns = max(columns, *array_columns);
cell **new_array = allocateArray(new_array_rows, new_array_columns);
if (new_array == NULL) {
printf("Error in ""resize"": Memory could not be allocated.\n");
return NULL;
} else {
for (size_t i = 0; i < *array_rows; i++) {
for (size_t j = 0; j < *array_columns; j++) {
new_array[i][j] = array[i][j];
}
}
free(array);
}
*array_rows = new_array_rows;
*array_columns = new_array_columns;
return *arrayp = new_array;
}
return array;
}
void displayArray(size_t rows, size_t columns, cell **array)
{
for (size_t row = 0; row < rows; row++) {
for (size_t col = 0; col < columns; col++) {
cell c = array[row][col];
printf(" {%d,%d,'%c'},", c.variable_1, c.variable_2, c.character);
}
printf("\n");
}
}
int main(void)
{
size_t array_rows = 3;
size_t array_columns = 3;
cell **array = allocateArray(array_rows, array_columns);
if (array == NULL) {
printf("Error in ""main"": Memory could not be allocated.\n");
return 3;
}
initialiseArray(array_rows, array_columns, array);
printf("before resize:\n");
displayArray(array_rows, array_columns, array);
if (!resizeArray(4, 5, &array_rows, &array_columns, &array)) {
printf("Memory error. We stop the program.\n");
return -1;
}
printf("after resize:\n");
displayArray(array_rows, array_columns, array);
free(array);
return 0;
}

Output:

before resize:
{0,0,' '}, {0,1,' '}, {0,2,' '},
{1,0,' '}, {1,1,' '}, {1,2,' '},
{2,0,' '}, {2,1,' '}, {2,2,' '},
after resize:
{0,0,' '}, {0,1,' '}, {0,2,' '}, {0,0,''}, {0,0,''},
{1,0,' '}, {1,1,' '}, {1,2,' '}, {0,0,''}, {0,0,''},
{2,0,' '}, {2,1,' '}, {2,2,' '}, {0,0,''}, {0,0,''},
{0,0,''}, {0,0,''}, {0,0,''}, {0,0,''}, {0,0,''},

Refer to @chqrlie's answer for a detailed critique of your code. I just want to address this:

> my code does not work, but my compiler, strangely, does not throw a warning.

The compiler cannot detect every possible thing you could do wrong, and it is not obligated to diagnose anything other than violations of the language's formal constraints. (And for anything else, it should be able to generate code.)

However, I'm skeptical of your claim. If the compiler does not diagnose the facts that

• your resizeArray() function can terminate without returning a value,

• your resizeArray() function can return a value whose type is mismatched with the function's declared return type,

• your main() contains unreachable code, and

• array = new_array in main contains a type mismatch

then either your compiler isn't very good, or you've disabled (some) warnings, or you're some other way discarding or missing diagnostics that it is, in fact, emitting.

As it turns out, your
>
> initialiseArray(array_rows, array_columns, *array);
>

will also contain a type mismatch at runtime, but inasmuch as this involves variably-modified types, I wouldn't really expect the compiler to diagnose it.