根据用户输入构造2D数组的正确方法

Question

I know that there have been many questions belonging to the family of "multi-dimensional arrays". Since I couldn't find a specific question which clears my issue, I am finally asking it.

Objective : Store a 2D array whose values are input from the user.

---

Method-01 : Using arbitrarily large initial size for the array.

Code :

int method_arbit()
{
 int n, m;
 int i, j;
 float myarray[100][100];

 printf("Enter the number of rows: ");
 scanf("%d", &m);

 printf("Enter the number of columns: ");
 scanf("%d", &n);

 for(i=0; i<m; i++)
 {
     for(j=0; j<n; j++)
         scanf("%f", &myarray[i][j]);
 }

 for(i=0; i<m; i++)
 {
     for(j=0; j<n; j++)
         printf("[%d][%d] = %f", i, j, myarray[i][j]);
 }
}

Comments : This function works as expected !

---

Method-02 : Using dynamic memory allocation.

Code :

int method_dynamic()
{
 int n, m;
 int i, j;
 float **myarray; // m x n matrix

 printf("Enter the number of rows: ");
 scanf("%d", &m);

 printf("Enter the number of columns: ");
 scanf("%d", &n);

 myarray = malloc(m*sizeof(float*));
 for(i=0; i<m; i++)
     myarray[m] = malloc(n*sizeof(float));

 for(i=0; i<m; i++)
 {
     for(j=0; j<n; j++)
         scanf("%f", &myarray[i][j]);
 }

 for(i=0; i<m; i++)
 {
     for(j=0; j<n; j++)
         printf("[%d][%d] = %f", i, j, myarray[i][j]);
}
}

Comments : This method gives Segmentation Fault upon taking input.

Q1: I'm having a hard time debugging this. Moreover, I'm finding it even harder to understand the reasoning behind this behavior. I have a basic understanding of pointers and dynamic memory allocation. I would appreciate a detailed explanation of the mistake I am making and the concepts I might be overlooking.

Q2: Is it advisable to say that if we don't know the size of the array at compile time, we should always dynamically allocate the array?
OR
When is it advisable to use a dynamically allocated array? One use case I know is while dealing with functions and returning arrays from them.

Answer 1

OP's problem is using the wrong index @forcebru

 myarray = malloc(m*sizeof(float*));
 assert(myarray); // Do some allocation check;
 for(i=0; i<m; i++) {
     //         v----- here
     // myarray[m] = malloc(n*sizeof(float));
     myarray[i] = malloc(n*sizeof(float));   
     assert(myarray[i]);
 }

Answer 2

You can declare multidimension array as a big array.

 int n, m;
 int i, j;
 float* myarray; // m x n matrix

 std::cout<<"Enter the number of rows: \n";
 scanf("%d", &m);

 std::cout << "Enter the number of columns: \n";
 scanf("%d", &n);

 myarray = (float*)malloc( m * n * sizeof(float) );

 for(i=0; i<m; i++)
 {
     for (j = 0; j<n; j++) {
         scanf("%f", &(myarray[i * n  + j]));
     }
 }

 for(i=0; i<m; i++)
 {
     for(j=0; j<n; j++) {
         printf("[%d][%d] = %f", i, j, (myarray[i * n  + j]));
     }
 }

Answer 3

Q1 : you need a chunk of memory to hold a 2-d array of float's, your initial code of

float **myarray;
myarray = malloc( m * sizeof(float*) );

m = 3;   // for this example
n = 5;   // for this example

is a problem because your two dimensions are m and n . You are not using n there. Also you are doing sizeof(float*) and you don't want the size of a pointer to float . What is happening is, if sizeof( pointer to float) = { 8 bytes on a 64-bit system, 4 bytes on 32-bit system} then your malloc is reserving either 24 or 12 bytes respectively. But for only m units of memory when you really need m x n units {15 units for 15 unique values, which are of type float}.

so you want the size that a single float takes up in memory. Therefore you should be doing

float *myarray;  // not a double pointer
myarray = (float *) malloc( m * n * sizeof( float ) );

for example if sizeof( float ) = 4 bytes, then if m=3 and n=5 then you get 4x15 = 60 bytes of memory allocated. malloc returns a pointer to that chunk of memory, and you cast it's type into your declared pointer to it.

At this point it is up to you to index into that total chunk of 60 bytes, where *myarray points to the beginning of it and that's it. The compiler knows nothing else about how that chunk of memory is to be arranged or used other than the pointer to the beginning of it which is myarray and it is to a float data type. There is no way for malloc or the compiler to know the row or column size m and n which you are trying to use when you use the myarray[][] convention.

On your system, if sizeof( float ) is 4, then every 4 bytes within that 60 byte chunk can be a float value, giving you 15 values.

if you want to use the convention myarray[i][j] you cannot because you used malloc and it does not know how that 60 byte chunk of memory is divided up. You will have to do the math of [row][col] indexing into myarray manually such as

m = 3;   // max rows
n = 5;   // max columns

row = 2;  // value entered by user, must be < m
col = 3   // value entered by user, must be < n

*(myarray + (row*n) + col) = 1.2345;

Q2: yes i think it is best if you don't know the size of memory you'll need, to write good code getting all user inputs then figuring out the size of memory you'll need. Then use either malloc or calloc to allocate that memory, and if not successful {system doesn't have enough} then you handle that condition and write code accordingly. Only downside is if you write code that repeatedly calls malloc or calloc, then free's it and repeats this process many times, this can incur a lot of overhead.

Answer 4

You will never do this "for real". Getting user to enter a 2D matrix via stdin is a pedagogical toy problem to give to people learning C. One of the disadvantages of the exercise is that there isn't really a good answer, there are ways you can do it like creating an oversize buffer, or reallocating memory to grow, or querying the user for width and height before input of the variables. But nothing is entirely satisfactory.

In reality data is likely to come in a file format such as CSV. Parsing a CSV file is fairly difficult, but not so difficult that any competent programmer shouldn't be able to achieve it. The usual way is to read in the structure into a memory structure, then "parse the output of the parser" to get it into a flat 2D array (or 1D array of structures, quite common with CSV files).