Confused with double dimension array equivalent - c

Question

my row size is fixed but the column size keeps varying all the time.That's why I am thinking to use pointers for column level.But I am not sure how to use this feature in C.Please kindly help me.
int array[rows][columns]; //row size fixed but column size is not fixed.

Answer 1

If all but one dimension of your array are fixed, which is the situation that you describe, you can avoid using arrays of pointers: you could typedef a row as int[rows], and create an array of rows, like this:
typedef int row_t[rows];
Now you can pass around 2D arrays composed of row_t arrays like this:
int total(row_t array[], int len) {
int res = 0;
for (int c = 0 ; c != len ; c++) {
for (int r = 0 ; r != rows ; r++) {
res += array[r][c];
}
}
return res;
}
int main() {
row_t *matrix = malloc(columns*sizeof(row_t));
for (int c = 0 ; c != columns ; c++) {
for (int r = 0 ; r != rows ; r++) {
matrix[r][c] = r*r+c*c;
}
}
printf("%d\n", total(matrix, columns));
free(matrix);
return 0;
}

Answer 2

You need to declare an array of pointers. Like this:
int *array[rows];
Later, according to the need, allocate memory to each row. You can use malloc or calloc functions for this.
for(int i=0; i<rows; i++){
array[i] = (int *) malloc(columns * sizeof(int));
}
This method also allows one to have rows with varying sizes.

Answer 3

you cannot use variable in array dimensions so use pointer to pointers
int **array;
array = (int **)malloc(sizeof(int *) * rows);
for (int i = 0; i < rows; ++i) {
array[i] = (int *)malloc(sizeof(int) * columns);
for (int j = 0; j < columns; j++) {
array[i][j] = value;
}
}
and ofcourse do not forget to free it all

Answer 4

You would do this by having an array of int*, e.g.
int* array[row];
for (int i = 0; i < row; ++i)
array[i] = (int*)malloc(i * sizeof(int));
And then you can access the data the same as if it was static.
int val = array[myRow][myColumn];
You'll have to be sure to free the memory in the same pattern as you allocated it.

Answer 5

Since 13 years now C allows dynamic sizes in the declaration of arrays. This is called variable length array, VLA.
If you really have large arrays, this might explose your stack. But you can still allocate such a beast with malloc and have all the simplicity of a 2D array:
size_t n = SOME_COMPLICATED_VALUE;
size_t m = ANOTHER_ONE;
double (*A)[n] = malloc(double[m][n]);

Answer 6

If each row can have a different number of columns, then the general approach is to declare an array of pointers, and then for each row dynamically allocate the number of elements for that row:
int *array[ROWS];
array[i] = malloc(sizeof *array[i] * number_of_columns_for_row_i);
Note that when you are done, you'll have to free each row individually:
for (i = 0; i < ROWS; i++)
free(array[i]);
If all the rows have the same number of columns, but that number can change for each instance of the array, then you have several choices. If you're using a C99-compliant compiler, you can use a variable length array, where the array dimension isn't known until runtime:
int columns;
// get number of columns somehow
int array[ROWS][columns];
VLAs are handy, but have their limitations; they cannot be members of struct or union types, and they cannot be declared static or at file scope. The big advantage of this approach is that you don't have to worry about deallocating anything when you're done. The big disadvantage of this approach is that you may not have enough memory to satsify the request; the memory space available for auto variables is typically quite limited compared to memory for dynamically-allocated objects. Also, the latest revision of the language standard (C11) makes VLAs optional, so they may not be available in all implementations going forward.
Alternately, you could dynamically allocate the array like so:
int (*array)[ROWS];
int columns;
// get number of columns somehow
array = malloc(sizeof *array * columns);
Note that this time, array is a pointer to an array of int, not an array of pointers to int. The benefit of this approach is that the array memory is allocated contiguously, and free-ing the memory is as simple as writing
free(array);
The drawback is that if your array is really big or the dynamic memory pool is really fragmented, you may not have a large enough chunk of memory available to satisfy the request.
If you don't need all the rows to be allocated contiguously, then use the first approach that allocates each row individually; just use the same value for the number of columns:
int *array[ROWS];
int columns;
// get number of columns
for (i = 0; i < ROWS; i++)
array[i] = malloc(sizeof *array[i] * columns);