How do I assign values to a matrix inside a struct? - c

Question

I have a header file with this type definition:
typedef struct {
int rows;
int columns;
int **values;
} bidimensional_matrix;
As an example, If I instantiate the matrix from a main function I'd just do:
int matrix[][] = {{1, 2, 3}, {1, 1, 1}, {5, 5, 5}};
How would you generate the same matrix but with the typedef provided previously? (I mean, with pointers and malloc)
Is the approach correct? Maybe I'm a little object oriented biased and in c it's not convenient to handle it that way. I've defined the struct that way so I can just pass two bidimensional_matrix by parameter and do a multiplication.

Answer 1

I propose you to use flexible member array, exemple:
#include <stdio.h>
#include <stdlib.h>
typedef struct {
size_t n;
size_t m;
int matrix[];
} bidimensional_matrix;
bidimensional_matrix *new_bidimensional_matrix(size_t n, size_t m) {
bidimensional_matrix *bm = malloc(sizeof *bm + sizeof *bm->matrix * n * m);
if (!bm) {
return NULL;
}
*bm = (bidimensional_matrix){ .n = n, .m = m };
return bm;
}
int get_bidimensional_matrix(bidimensional_matrix *bm, size_t i, size_t j) {
return bm->matrix[i * bm->m + j];
}
int set_bidimensional_matrix(bidimensional_matrix *bm, size_t i, size_t j, int x) {
return bm->matrix[i * bm->m + j] = x;
}
int main(void) {
bidimensional_matrix *bm = new_bidimensional_matrix(5, 10);
if (!bm) {
return EXIT_FAILURE;
}
for (size_t i = 0; i < bm->n * bm->m; i++) {
bm->matrix[i] = i;
}
printf("sample value %d\n", get_bidimensional_matrix(bm, 4, 5));
set_bidimensional_matrix(bm, 4, 5, 42);
printf("sample value %d\n", get_bidimensional_matrix(bm, 4, 5));
free(bm);
}
But you could use this too, that have other avantage but generally is more slow:
#include <stdio.h>
#include <stdlib.h>
typedef struct {
size_t n;
size_t m;
int **matrix;
} bidimensional_matrix;
int main(void) {
bidimensional_matrix bm = { .n = 5, .m = 10, .matrix = malloc(sizeof *bm.matrix * bm.n) };
if (!bm.matrix) {
return EXIT_FAILURE;
}
for (size_t i = 0; i < bm.n; i++) {
bm.matrix[i] = malloc(sizeof *bm.matrix[i] * bm.m);
if (!bm.matrix[i]) {
return EXIT_FAILURE;
}
for (size_t j = 0; j < bm.m; j++) {
bm.matrix[i][j] = i * bm.m + j;
}
}
printf("sample value %d\n", bm.matrix[4][5]);
for (size_t i = 0; i < bm.n; i++) {
free(bm.matrix[i]);
}
free(bm.matrix);
}
If you need to swap rows the second could be a little faster cause swap row are O(1). But like you see the first one has only one malloc(), in practice with the cache of the processor it should be a lot more faster than the second implementation.