Passing 2D array as a function argument whose dimensions are known only at runtime

Question

I have seen many questions of this type on SO, but nothing really helped.I'm a newbie in C++.

#include<iostream>
using namespace std;

int func(int i,int j,int r,int c,int **A)
{
    //do something
}

int main(void)
{
    int r,c;
    cin>>r>>c;
    int A[r][c];
    //read array
    for(int i=0;i<r;i++){
        for(int j=0;j<c;j++){
            cin>>A[i][j];
        }
    }
    if(func(0,0,r,c,A)){
        cout<<1<<endl;
    }
    else{
        cout<<0<<endl;
    }
}

this gives the following error

error: cannot convert ‘int (*)[c]’ to ‘int**’ for argument ‘5’ to ‘int func(int, int, int, int, int**)’ if(func(0,0,r,c,A)){

Answer 1

The easiest way without using additional template libraries is pointer to pointer.

int **A;
A = new int *[r];
for(int i = 0; i <r; i++)
    array[i] = new int[c];

for(int i=0;i<r;i++){
    for(int j=0;j<c;j++){
        cin>>A[i][j];
    }
}

if(func(0,0,r,c,A)){
    cout<<1<<endl;
} else {
    cout<<0<<endl;
}

Answer 2

For starters Variable Length Arrays is not a standard C++ feature. It can be a language extension of the compiler that can not be supported by other compilers.

So instead of a variable length array use standard container std::vector.

To solve your problem with using arrays you can define a template function. For example

template <size_t M, size_t N>
int func( int i, int j, int ( &a )[M][N] )
{
    //do something
}

If to use the compiler that supports VLAs then at least the function could look like

int func(int i,int j,int r,int c, int A[r][c] )
{
    //do something
}

Answer 3

The old fashioned method is to allocate your array as a one dimensional array, then index it as a 2d array:

int * my_array = new int[m * n];

Next, passing to a function, you can pass by pointer to the first element, then pass the row and column capacities:

void Process_Array(int * array, size_t max_rows, size_t max_columns);

//...
Process_Array(my_array, m, n);

The index can be calculated as:

size_t array_index = row * n + column;

Answer 4

This is not a direct answer, as others have already presented actual solutions, but more an explanation on the why it is so complex and what are the idiomatic C++ alternatives to dynamic multi-dimensional arrays.

C++ fellows say that raw array management is not for common programmers but should be reserved to library implementers. For that reason, nothing is done to easily pass multi dimensional arrays along with their sizes to functions, while it used to be common in Fortran IV in the 80s.

The C++ ways are (from the simpler to the harder):

• use a vector<vector<int>> a vector can be used like a dynamic size array, so a vector can be used like a 2D array, provided you do not need contiguous allocation

• implement a wrapper class around a contiguous 1D array of size r*c that presents access to cells with a function returning a reference:

  int& cell(int i, int j) { return (arr + i * c)[j]; }
  

  I say it is easier because it can be extended to multi dimension arrays (more than 2D)

• implement a wrapper class around a contiguous 1D array of size r*c that present a 2D array interface (arr[i][j] = x;). In fact it is enough to implement an operator[] that returns a pointer to the first element of a row. It can still be extended to n-D arrays (n>2) but it becomes tougher.

Finally, one of the major reasons is that there are few real use cases for contiguous n-D arrays of variable size. So you should wonder whether a vector<vector>, or a plain 1D array of size r*c are not enough.

Answer 5

You can create matrixes in runtime on C++ if you think a matrix as a vector of vectors, and put a bit of memory allocation on it.

using a bit of C:

int **createMatrix(int cols, int rows) {
    int **matrix = malloc(sizeof(int*) * cols);
    for(int i = 0; i < cols; ++i) {
        matrix[i] = malloc(sizeof(int) * rows;
    }
    return matrix;
}

then you can use your newly created matrix just you would use any other matrix created with [][].