Return a 2D array of user-given size

Question

I want to create a function that

takes the row and column as arguments.
takes inputs according to the given size and
returns the 2D matrix/array.

I've gone through lots of solutions online, but everything I try, gives me some new errors.

int* input_taker(int row, int col)
{
    int mat[row][col];
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
        {
            scanf("%d", &mat[i][j]);
        }
    }
    return mat;
}

What errors are you getting? I am only getting warnings, and the program compiles successfully. — Wais Kamal, Jul 15 '21 at 07:54
@WaisKamal Warnings must be taken seriously!! And in this case they warn about illegal code — Support Ukraine, Jul 15 '21 at 07:55
@foragerDev I don't much about it. My teacher just taught C. — Sheikh Abdullah, Jul 15 '21 at 07:56
@WaisKamal What is being returned? What is the storage duration of the returned object? — Support Ukraine, Jul 15 '21 at 07:56
Oh yes, the returned pointer becomes a dangling pointer. Just noticed that :) — Wais Kamal, Jul 15 '21 at 07:57
@WaisKamal `Error] cannot convert 'int* (*)[col]' to 'int*' in return` — Sheikh Abdullah, Jul 15 '21 at 07:57
@SheikhAbdullah C or C++ make up your mind. Answer will be very different. — Jabberwocky, Jul 15 '21 at 07:58
Does [Can double pointers be used as 2D arrays](https://stackoverflow.com/questions/68251484/can-double-pointers-be-used-as-2d-arrays/68251871#68251871) help? — foragerDev, Jul 15 '21 at 08:02
It does not matter *how* you return the array: you can't make a variable length array on the heap, therefore you can't do this. It will go out of life when the function returns. — Weather Vane, Jul 15 '21 at 08:12
@4386427 the VLA usually goes on the stack, so it can't survive the return from function. Unlike using `malloc` it doesn't go on the heap. — Weather Vane, Jul 15 '21 at 08:20
@4386427 my comment said that even if OP fixes the value returned, it still won't be right. — Weather Vane, Jul 15 '21 at 08:23
@4386427 "you can't make a variable length array on the heap" (i.e. static) it has to be on the stack. — Weather Vane, Jul 15 '21 at 08:25

Support Ukraine · Accepted Answer · 2021-07-15T09:46:50.800

The function return type is int* but you are trying to return mat which has a different type (i.e int* (*)[col]) so that's a bug.
mat is a function local variable so it doesn't exists once the function returns. In other words - returning mat makes no sense at all. You are returning a reference to a "dead" object.

Instead you need to use dynamic allocation in the function so that the returned object still exist after function return.

For this you can define mat as a pointer to an array of col integers. Further, the function shall return a pointer to an array of integers.

Like:

#include <stdio.h>
#include <stdlib.h>

int (* input_taker(int row, int col))[]
{
    int (*mat)[col] = malloc(row * sizeof *mat);
    if (mat == NULL) exit(1);
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
        {
            mat[i][j] = i*col + j;  // Here you can read user input
        }
    }
    return mat;
}

int main ()
{
    int col = 8;
    int row = 5;
    int (* p)[col] = input_taker(row, col);
    for (int i=0; i<row; ++i)
    {
        for (int j=0; j<col; ++j)
        {
            printf("%5d ", p[i][j]);
        }
        puts("");
    }
    free(p);
    return 0;
}

Output

    0     1     2     3     4     5     6     7 
    8     9    10    11    12    13    14    15 
   16    17    18    19    20    21    22    23 
   24    25    26    27    28    29    30    31 
   32    33    34    35    36    37    38    39

@PaulOgilvie Feel free to post "a lot simpler, equivalent, solution" as an answer. It will help OP and others. I don't know any better way than using "pointer to array" when dealing with constant numbers of columns. — Support Ukraine, Jul 15 '21 at 08:35
@PaulOgilvie: There is nothing over the top about this answer. It provides a simple and well-defined way to create a two-dimensional array. — Eric Postpischil, Jul 15 '21 at 11:01
@4386427 It was a little difficult to understand by a beginner like me. But it solved my problem. Thanks for that. — Sheikh Abdullah, Jul 16 '21 at 08:15
@SheikhAbdullah Study the difference between `int *p[]` and `int (*p)[]` See e.g. https://cdecl.org/ — Support Ukraine, Jul 16 '21 at 09:12

Costantino Grana · Answer 2 · 2021-07-15T08:43:04.783

2

Other answers used VLAs as in your original question. The point is that I don't think VLAs are the way to go for matrices, since it's not unlikely to have the same variable change size during execution, and this requires a murky design with VLAs.

If you renounce to the double square brackets syntax, using a simple pointer is pretty straigthforward (I'm adapting 4386427 code for this):

#include <stdio.h>
#include <stdlib.h>

int *input_taker(int row, int col)
{
    int *mat = malloc(row * col * sizeof *mat);
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            mat[i * col + j] = i * col + j;  // Here you can read user input
        }
    }
    return mat;
}

int main ()
{
    int col = 8;
    int row = 5;
    int *p = input_taker(row, col);
    for (int i = 0; i < row; ++i) {
        for (int j = 0; j < col; ++j) {
            printf("%5d ", p[i * col + j]);
        }
        puts("");
    }
    free(p);
    return 0;
}

Even better pack everything in a struct:

struct mat {
    int rows, cols;
    int *data;
};

and provide functions to use it.

edited Jul 15 '21 at 08:43

answered Jul 15 '21 at 08:39

Costantino Grana

3,132
1
15
35

This is not a 2D array but 1D array which lead to error prone indexing – Support Ukraine Jul 15 '21 at 08:42
"this requires a murky design with VLAs." No, it's straight forward to change number of rows. Changing number of cols is equally difficult with your solution – Support Ukraine Jul 15 '21 at 08:44
@4386427 The access through a struct should solve that concern. – Costantino Grana Jul 15 '21 at 08:44
Why make simple things complicated? – Support Ukraine Jul 15 '21 at 08:46
@4386427 A good question. I guess that Paul Ogilvie comment to your answer shows how "complicated" is not always agreed on. – Costantino Grana Jul 15 '21 at 08:49
Well, "pointer to array" is a pretty basic C construct that one must master to write efficient C code for multidimental array processing. – Support Ukraine Jul 15 '21 at 08:56

score 2 · Answer 3 · answered Jul 15 '21 at 12:25

2D array of user-given size

and

pointer to an array of col integers.

both seem to avoid the term VLA. 4386's answer gives the "C90 forbids VLA" warning with -Wvla.

This

int mat[row][col];

dose not work because it is auto storage.

But

int (*mat)[col];

is only a pointer to a VLA; it can be malloced and returned.

To (over-)simplify 4386's function type and to split the definition of mat this can be done:

void *array_maker(int row, int col)   // just a pointer; no dimensions, no type
{
    int (*mat)[col];                  // declare runtime inner dim.: ptr to VLA  
    mat = malloc(row * sizeof *mat);  // mallocate both dims

    for (int i = 0; i < row; i++)
    for (int j = 0; j < col; j++)
            mat[i][j] = i*col + j;    // fill the array[][] 
    return mat;
}

The call from main is:

int col, row;

int (*p)[col=8];                  // ptr. to VLA  
p = array_maker(row=5, col);      // implicit cast from void-ptr

Since a VLA is involved anyway, one might turn it around and put the array pointer into a param. This turns the function from array-maker to array-filler:

void array_filler(int row, int col, int mat[][col])
{
    for (int i = 0; i < row; i++)
    for (int j = 0; j < col; j++)
            mat[i][j] = i*col + j;    // fill the array[][] 
}

Now the array has to be allocated by the caller - either as auto-VLA or malloced VLA-pointer or fixed-size array:

col=row=9;
int mat[row][col];  
//int (*mat)[col] = malloc(row * sizeof*mat); 
//int mat[9][9];
array_filler(row, col, mat);

int mat[row][col]; wrong storage duration

int* input_taker(int row, int col) -> incompatible type warning

score 1 · Answer 4 · answered Jul 15 '21 at 08:22

Your problem appears to be a dangling pointer. You have to allocate memory before calling input_taker.

#include <cstdio>
#include <cstdlib>

int* input_taker(int *ptr, int row, int col)
{
    for (int i = 0; i < row; i++)
    {
        int *arr = &ptr[i*col];
        for (int j = 0; j < col; j++)
        {
            scanf("%d", &arr[j]);
        }
    }
    return ptr;
}

int main() {
    int n_rows, n_cols;
    n_rows = 2;
    n_cols = 3;
//    int *matrix = (int*)malloc(n_rows*n_cols*sizeof(int));
    int matrix [n_rows][n_cols];
    input_taker(&matrix[0][0], n_rows, n_cols);

    for (int i = 0; i < n_rows; i++)
    {
        printf("[");
        for (int j = 0; j < n_cols; j++)
        {
            j==n_cols-1?printf("%d]\n", matrix[i][j]):printf("%d, ", matrix[i][j]);
        }
    }
    return 0;
}

I changed the function parameters but kept the return value. You may, however, return void.

Return a 2D array of user-given size

4 Answers4

Linked