Dynamic matrix and dynamic values into matrix - c

Question

This is my code - i init my own values (1 or 0) into a defined matrix.
instead of setting always a hardcoded matrix i want the user to set values and the dimantions of the matrix
scanf("%d %d", &height, &width);
and after building the matrix to initscan his value
scanf("%d", &vall);
Please help me with this i never done something dynamic this way and dont know how to load dynamix matrix with dynamic values straight from the user please show me your syntax for this so i could learn.
printf("How many Row : ");
scanf("%d", &nrow);
rowptr = malloc(sizeof(int) * nrow);
printf("How many Column : ");
scanf("%d", &ncol);
thank you
#include <stdio.h>
#define WIDTH 50
#define HEIGHT 20
void init(int board[][WIDTH], int rows) {
int x, y;
for (y = 0; y < rows; y++)
for (x = 0; x < WIDTH; x++)
board[y][x] = 0;
/* Scatter some live cells: */
board[10][25] = 1;
board[10][26] = 1;
board[10][27] = 1;
board[11][25] = 1;
board[12][26] = 1;
}

Answer 1

You can use malloc() function for this. malloc() takes the number of bytes as parameter and returns a void pointer on success. You'll need to cast it to the pointer of the appropriate data type to use it. Here's an example:
int **board;
scanf("%d %d", &height, &width);
// first allocate memory for pointer to each row
board = (int**) malloc(height * sizeof(int*));
// then allocate memory for each row
for(i = 0; i < height; i++)
board[i] = (int*) malloc(width * sizeof(int));
And when you're done, free up the allocated memory to avoid memory leak. You have to free them in reverse order:
// first free up each row
for(i = 0; i < height; i++)
free(board[i]);
// then free up the pointers to the rows
free(board);
Edit:
For your code, do this:
printf("How many Row : ");
scanf("%d", &nrow);
rowptr = (int**) malloc(sizeof(int) * nrow);
printf("How many Column : ");
scanf("%d", &ncol);
for(i = 0; i < nrow; i++)
rowptr[i] = (int*) malloc(ncol * sizeof(int));

Answer 2

You have to use the malloc() function to assign memory dinamically. It returns a pointer to a block of memory of the requested size. Here's an example:
int size;
int *foo;
printf("How many elements? ");
scanf("%d", &size);
foo = malloc(size * sizeof(int));
// always check if the call succeeded
if(foo == NULL) {
printf("can't allocate memory!");
return;
}
int i;
for(i = 0; i < size; i++) {
printf("enter value for element #%d: ", i + 1);
scanf("%d", &foo[i]);
}
// ...
free(foo); // to avoid memory leaks
free() tells the os that the block you pass in is no longer in use, so it's available for the future.
Now, since you want a matrix, you need a double pointer and you have to call malloc for every "row" (error checking removed for clarity):
int **matrix = malloc(rows * columns * sizeof(int));
int i;
for(i = 0; i < rows; i++)
matrix[i] = malloc(columns * sizeof(int));

Answer 3

To have a solution with a full dynamic arrays of arrays (a 2D matrix with number of rows and columns unknown at compile time), you should use an int ** type to represent your matrix.
int **board = malloc(height * sizeof *board);
for (i = 0; i < height; i++)
board[i] = malloc(width * sizeof **board);
then prototype your functions with an int ** for the board parameter and access your matrix as usual:
int x = board[i][j]; // store in x the element of row i and column j

Answer 4

If you have modern C, say C99, initializing a matrix dimension with variable content is possible. It is called variable length array, VLA. On what concerns your code, you are almost there. Just change your prototypes to something like the following
void init(size_t cols, size_t rows, int board[rows][cols])
such that the bounds come first and are known when you come to the declaration of the matrix.
You could principally allocate such matrices on the stack
int board[rows][cols];
(without initializer) would do, but if your dimension get large you'd risk stack overflow. To declare a matrix on the heap, you could do something like
int (*board)[cols] = malloc(int[rows][cols]);
don't forget to assign initial values to the individual entries board[i][j] and to free the whole matrix at the end of its use.
Edit: seeing all these answers that try to sell you simulations of 2D arrays via pointers to pointers. Don't do such complicated things, just do what the language provides you directly, VLA.