How to create variable length array on heap? [duplicate] - c

Question

This question already has answers here:
Dynamically creating a contiguous 5D array? [closed]
(6 answers)
Closed 6 years ago.
I used C's variable length array to implement an algorithm:
int matrix[rows][cols];
I managed to test that this does fail for ridiculous dimensions. Is there a way to allocate this matrix on heap instead of stack? Otherwise I'll have to rewrite this to int**...
Something like calloc(sizeof(int[rows][cols]), 1)? Note that this question is specifically about variable length arrays.

Answer 1

It looks simple enough. The only remotely tricky bit is the type to hold the pointer to the dynamically allocated array:
#include <stdlib.h>
#include <stdio.h>
static void print_matrix(int r, int c, int matrix[r][c])
{
for (int i = 0; i < r; i++)
{
for (int j = 0; j < c; j++)
printf(" %d", matrix[i][j]);
putchar('\n');
}
}
static void set_matrix(int r, int c, int matrix[r][c])
{
for (int i = 0; i < r; i++)
{
for (int j = 0; j < c; j++)
matrix[i][j] = (i+1) * 100 + j + 1;
}
}
int main(void)
{
size_t rows = 9;
size_t cols = 7;
size_t size = sizeof(int[rows][cols]);
printf("rows = %zu, cols = %zu, size = %zu\n", rows, cols, size);
int (*matrix)[cols] = calloc(sizeof(int[rows][cols]), 1);
if (matrix != 0)
{
set_matrix(rows, cols, matrix);
print_matrix(rows, cols, matrix);
free(matrix);
}
return 0;
}
This code carefully uses calloc() to zero all the elements of the array, and then calls set_matrix() to set them to non-zero values. As written, malloc() would be better than calloc(), but the question used calloc() and it would not be hard to make it sensible for use with this code too (for example, a conditional assignment in set_matrix(), such as if (i && j && i != j)).
Example output:
rows = 9, cols = 7, size = 252
101 102 103 104 105 106 107
201 202 203 204 205 206 207
301 302 303 304 305 306 307
401 402 403 404 405 406 407
501 502 503 504 505 506 507
601 602 603 604 605 606 607
701 702 703 704 705 706 707
801 802 803 804 805 806 807
901 902 903 904 905 906 907

Answer 2

You can create a pointer to a VLA:
size_t rows, cols;
... // get values for rows and cols
T (*arr)[cols] = malloc( sizeof (T [cols]) * rows );
if ( arr )
{
...
arr[i][j] = some_value;
...
}
There is some debate over whether
T (*arr)[cols] = malloc( sizeof *arr * rows );
should work. The way the standard is worded, this form results in undefined behavior, since sizeof has to evaluate *arr at runtime (since the expression *arr refers to a VLA), and arr is an invalid pointer when sizeof *arr is evaluated.
However, it depends on what "evaluate" means in that particular context; there's no reason to have to dereference arr in order to determine the size of the array it points to, any more than you would for a fixed-length array:
T (*arr)[10] = malloc( sizeof *arr * rows );
I and a few others are of the opinion that the standard is poorly worded in this respect, and that sizeof *arr should be valid whether arr points to a fixed- or variable-length array. This is the idiom I use and it hasn't failed on me...yet.
But, I would be remiss if I didn't point out this issue, and provide you with something that I know won't result in UB.