分配从文件读取的二维尺寸数组

Question

I would like to read 2 numbers n,m from text file and then allocate a 2D array with n rows and m columns.

Also, I would like to initialise the array in my main function in order to use it later in other functions, and do the reading and allocating in a different function, which I will call from the main function.

I know how to handle the reading, but I'm struggling with the array allocation.

I've read quite a few answer to similar questions here, but they didn't help me.

I've wrote the following code, but not sure how to continue with it to get the desired result:

void func(int** array, int* rows, int* cols){
  int n, m;
  FILE *file;
  fp = fopen("test.txt", "r");
    if (file) {
    /* reading numbers n and m */
    *rows = n;
    *cols = m;
    **array = (int*)malloc(n * m * sizeof(int));
    fclose(file);
  }
}

int main() {      
  int rows, cols;
  int** array;
  func(&array, &rows, &cols);
  return 0;
}

I thought perhaps I should first allocate a 2D array with calloc and then use realloc after reading n,m , but not sure if that's the best practise.

What is the best practise to allocate a 2D array based on dimensions I read from text file?

Answer 1

First the biggest goofs here:

• Your function doesn't have any types in the function signature -- this should be rejected by the compiler
• a 2D array is not the same as an array of pointers
• what should && mean? & is the address of something, its result can't have an address because it isn't stored anywhere, so this doesn't make sense

If you want to dynamically allocate a real 2D array, you need to either have the second dimension fixed or use VLAs (which are optional in C11, but assuming support is quite safe) with a variable. Something like this:

// dimensions in `x` and `y`, should be of type `size_t`
int (*arr)[x] = malloc(y * sizeof *arr);

In any case, the second dimension is part of the type, so your structure won't work -- the calling code has to know this second dimension for passing a valid pointer.

---

Hint: This first part doesn't apply to the question any more, OP forgot to mention he's interested in C90 only. I added the appropriate tag, but leave the upper part of the answer for reference. The following applies to C90 as well:

---

You write int ** in your code, this would be a pointer to a pointer. You can create something that can be used like a 2D array by using a pointer to a pointer, but then, you can't allocate it as a single chunk.

The outer pointer will point to an array of pointers (say, the "row-pointers"), so for each of these pointers, you have to allocate an array of the actual values. This could look like the following:

// dimensions again `x` and `y`
int **arr = malloc(y * sizeof *arr);
for (size_t i = 0; i < y; ++i)
{
    arr[i] = malloc(x * sizeof **arr);
}

Note on both snippets these are minimal examples. For real code, you have to check the return value of malloc() each time . It could return a null pointer on failure.

---

If you want to have a contiguous block of memory in the absence of VLAs , there's finally the option to just use a regular array and calculate indices yourself, something like:

int *arr = malloc(x * y * sizeof *arr);

// access arr[8][15] when x is the second dimension:
arr[x*8 + 15] = 24;

This will generate (roughly) the same executable code as a real 2D array, but of course doesn't look that nice in your source.

---

Note this is not much more than a direct answer to your immediate question. Your code contains more goofs. You should really enable a sensible set of compiler warnings (eg with gcc or clang , use -Wall -Wextra -pedantic -std=c11 flags) and then fix each and every warning you get when you move on with your project.