How to allocate triangular array using single malloc in C? - c

Question

I am trying to allocate triangular array using single malloc but I could'nt find any solution for this. My structure is something like this :
a - - - -
b c - - -
d e f - -
g h i j -
k l m n o
I've made it using two malloc.

Answer 1

How are you planning to use the structure — what code would you write to access an array element? Also, what size of array are you dealing with?
If the array is small enough (say less than 100x100, but the boundary value is negotiable) then it makes sense to use a regular rectangular array and access that as usual, accepting that some of the allocated space is unused. If the array will be large enough that the unused space will be problematic, then you have to work harder.
Do you plan to use lt_matrix[r][c] notation, or could you use a 1D array lt_matrix[x] where x is calculated from r and c? If you can use the 1D notation, then you can use a single allocation — as shown in Technique 1 in the code below. If you use the double-subscript notation, you should probably do two memory allocations — as shown in Technique 2 in the code below. If you don't mind living dangerously, you can mix things up with Technique 3, but it isn't recommended that you use it unless you can determine what the limitations and issues are and assess for yourself whether it is safe enough for you to use. (If you ask me, the answer's "No; don't use it", but that could be regarded as being over-abundantly cautious.)
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
static inline int lt_index(int r, int c) { assert(r >= c); return r * (r + 1) / 2 + c; }
int main(void)
{
int matrixsize = 5;
/* Technique 1 */
char *lt_matrix1 = malloc(matrixsize * (matrixsize + 1) / 2 * sizeof(*lt_matrix1));
assert(lt_matrix1 != 0); // Appalling error checking
char value = 'a';
for (int i = 0; i < matrixsize; i++)
{
for (int j = 0; j <= i; j++)
lt_matrix1[lt_index(i, j)] = value++;
}
for (int i = 0; i < matrixsize; i++)
{
int j;
for (j = 0; j <= i; j++)
printf("%-3c", lt_matrix1[lt_index(i, j)]);
for (; j < matrixsize; j++)
printf("%-3c", '-');
putchar('\n');
}
free(lt_matrix1);
/* Technique 2 */
char **lt_matrix2 = malloc(matrixsize * sizeof(*lt_matrix2));
assert(lt_matrix2 != 0); // Appalling error checking
char *lt_data2 = malloc(matrixsize * (matrixsize + 1) / 2 * sizeof(*lt_matrix1));
assert(lt_data2 != 0); // Appalling error checking
for (int i = 0; i < matrixsize; i++)
lt_matrix2[i] = &lt_data2[lt_index(i, 0)];
value = 'A';
for (int i = 0; i < matrixsize; i++)
{
for (int j = 0; j <= i; j++)
lt_matrix2[i][j] = value++;
}
for (int i = 0; i < matrixsize; i++)
{
int j;
for (j = 0; j <= i; j++)
printf("%-3c", lt_matrix2[i][j]);
for (; j < matrixsize; j++)
printf("%-3c", '-');
putchar('\n');
}
free(lt_data2);
free(lt_matrix2);
/* Technique 3 - do not use this */
void *lt_data3 = malloc(matrixsize * sizeof(int *) + matrixsize * (matrixsize + 1) / 2 * sizeof(int));
assert(lt_data3 != 0); // Appalling error checking
int **lt_matrix3 = lt_data3;
int *lt_base3 = (int *)((char *)lt_data3 + matrixsize * sizeof(int *));
for (int i = 0; i < matrixsize; i++)
lt_matrix3[i] = &lt_base3[lt_index(i, 0)];
value = 1;
for (int i = 0; i < matrixsize; i++)
{
for (int j = 0; j <= i; j++)
lt_matrix3[i][j] = value++;
}
for (int i = 0; i < matrixsize; i++)
{
int j;
for (j = 0; j <= i; j++)
printf("%-3d", lt_matrix3[i][j]);
for (; j < matrixsize; j++)
printf("%-3c", '-');
putchar('\n');
}
free(lt_data3);
return 0;
}
The output from the program is:
a - - - -
b c - - -
d e f - -
g h i j -
k l m n o
A - - - -
B C - - -
D E F - -
G H I J -
K L M N O
1 - - - -
2 3 - - -
4 5 6 - -
7 8 9 10 -
11 12 13 14 15
Valgrind version 3.13.0.SVN (revision 16398) gives this a clean bill of health on macOS Sierra 10.12.5 using GCC 7.1.0.

Answer 2

You can just malloc(width * height * sizeof(Object)) if you want to use one malloc and create one continuous array. If you want to access the (x, y) position, use: array[y * width + x].
Using two malloc just creates an array of pointers, which is a little different from a continuous array acting like a 2D array.