Array of Matrices with Different sizes in C - c

Question

I am trying to make an array of say 3 matrices with different sizes:
Array ={ {{1, 2, 3}, {10, 20, 30}},
{{4, 5}, {40, 50}, {400, 500}},
{{6, 7}, {60, 70}} };
I need to use array indexing rather than pointer arithmetic for my codes.
I think I should create a 1-d array containing 3 pointers to matrices. Something like:
{ *ptr1[3], *ptr2[2], *ptr3[2]}
But how can I declare such an object? Also how can I assign values to that?
I am readying the actual data from a binary file using fread.
Thank you,

Answer 1

Jagged array is array of arrays such that member arrays can be of different sizes, i.e., we can create a 2-D array but with a variable number of columns in each row.
#include <stdio.h>
#include <stdlib.h>
int main()
{
int Mat1row0[3] = { 1, 2, 3};
int Mat1row1[3] = {10, 20, 30};
int Mat2row0[2] = {4, 5};
int Mat2row1[2] = {40, 50};
int Mat2row2[2] = {400, 500};
int Mat3row0[2] = {6, 7};
int Mat3row1[2] = {60, 70};
int* jagged1[2] = {Mat1row0, Mat1row1 };
int* jagged2[3] = {Mat2row0, Mat2row1, Mat2row2};
int* jagged3[2] = {Mat3row0, Mat3row1 };
int** jaggedkk[3] = {jagged1, jagged2, jagged3};
printf("%d",jaggedkk[0][0][0]);
return 0;
}
The output is : 1

Answer 2

You could create a struct to represent a matrix and then create an array of that struct. Further, you would need a function for initializing a matrix (i.e. allocate memory) and also a function for deleting a matrix (i.e. free allocated memory).
Something like:
#include <stdio.h>
#include <stdlib.h>
typedef struct
{
size_t rows;
size_t columns;
int **data;
} Matrix;
void initMatrix(size_t rows, size_t columns, Matrix *m)
{
if (rows == 0 || columns == 0) exit(1); // error
// Allocate row pointers
m->data = malloc(rows * sizeof m->data[0]);
if (m->data == NULL) exit(1); // error
// Allocate data area, i.e. rows x columns ints
m->data[0] = malloc(rows * columns * sizeof m->data[0][0]);
if (m->data[0] == NULL) exit(1); // error
// Initialize the remaining row pointers
for (size_t i=1; i < rows; ++i)
{
m->data[i] = m->data[0] + i * columns;
}
m->rows = rows;
m->columns = columns;
}
void deleteMatrix(Matrix *m)
{
free(m->data[0]);
free(m->data);
m->rows = 0;
m->columns = 0;
m->data = NULL;
}
void printMatrix(Matrix *m)
{
printf("---------------------------\n");
printf("rows=%zu columns=%zu\n", m->rows, m->columns);
for (size_t i=0; i < m->rows; ++i)
{
printf("row[%zu] at %p\t", i, (void*)m->data[i]);
for (size_t j=0; j < m->columns; ++j)
{
printf("%d\t", m->data[i][j]);
}
printf("\n");
}
printf("---------------------------\n");
}
int main(void)
{
Matrix m[2];
initMatrix(2, 5, &m[0]);
for(size_t i=0; i < 2; ++i)
{
for(size_t j=0; j < 5; ++j)
{
m[0].data[i][j] = 10*i + j;
}
}
initMatrix(3, 2, &m[1]);
for(size_t i=0; i < 3; ++i)
{
for(size_t j=0; j < 2; ++j)
{
m[1].data[i][j] = 100 + 10*i + j;
}
}
for(size_t i=0; i < 2; ++i)
{
printMatrix(&m[i]);
}
for(size_t i=0; i < 2; ++i)
{
deleteMatrix(&m[i]);
}
return 0;
}
Possible output:
---------------------------
rows=2 columns=5
row[0] at 0x1979030 0 1 2 3 4
row[1] at 0x1979044 10 11 12 13 14
---------------------------
---------------------------
rows=3 columns=2
row[0] at 0x1979080 100 101
row[1] at 0x1979088 110 111
row[2] at 0x1979090 120 121
---------------------------

Answer 3

A 'short/simple' solution could be just to write:
int *** Array =(int**[]){ (int*[]){(int[]){1, 2, 3}, (int[]){10, 20, 30}},
(int*[]){(int[]){4, 5}, (int[]){40, 50}, (int[]){400, 500}},
(int*[]){(int[]){6, 7}, (int[]){60, 70}} };
Now Array[0][0][0] will be 1, Array[2][1][1] will be 70, etc;
If you need to do it dynamically, you can do it the following way:
int *** Array;
Array = malloc(sizeof(int**)*3);
Array[0] = malloc(sizeof(int*)*2);
Array[0][0] = malloc(sizeof(int)*3);
Array[0][0][0] = 1;
...
(and so on)