Can't declare dynamic 2D array in C++ [duplicate]

Question

I've stuck on a problem - I can't declare 2D arrays in C++ using integers, written by user.

This code works fine-

cin>>m>>n;
int *array;
array=new int[m*n];

But I can't make this work -

cin>>m>>n;
int *array;
array=new int[m][n];

Any ideas how i can bypass it? P.S. the error : cannot convert 'int ()[2]' to 'int' in assignment.

Answer 1

Change

cin>>m>>n;
int *array;
array=new int[m][n];

to

cin>>m>>n;
int **array;
array=new int * [m];

for ( int i = 0; i < m; i++ ) array[i] = new int[n];

Answer 2

You can do this:

typedef int RowType[n];
RowType *array = new RowType[m];

doStuffWith(array[y][x]);

Or, even shorter (but harder to remember):

int (*array)[n] = new (int[m][n]);

---

Edit:

There is a catch in C++ that array sizes must be constant for the new operator, so you can only do this if n is const. This is not a problem in C (and the reason I forgot about this), so the following works even if n and m are not const:

RowType *array = (RowType*)malloc(m * sizeof(RowType));

Of course, you can work around this restriction in C++ by doing this, which works even if both m and n are dynamic:

RowType *array = (RowType*)new int[m * n];

The typedef free version would be this:

int (*array)[n] = (int (*)[n])new int[m *n];

Answer 3

array is int * and you try to assign int **... change array to int**.

2D array is actually array of arrays, so you need pointer to pointer.

Answer 4

That's because you can only use new to allocate 1D arrays. In fact, 2D arrays are also 1D arrays, where, in most systems, all rows are simply concatenated. That is called a row-major memory layout.

You can emulate 2D arrays with a 1D array. The index conversion is:

index1 = y * m + x

This also has much better performance than creating one array per row, as recommended in the "duplicate" link or in other answers.

Answer 5

Just as Domi said (but not index1=y*m+x but rather index1=x*n+y to emulate your desired notation):

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

int get (int x, int y) // emulates array[x][y] for array[m][n]
{
    return array[x*n+y];
}

However, I think the real 2-dimensional allocation (as Vlad from Moscow showed you) is slower in creation (and needs a bit more memory), but quicker in accessing. Cause array[x*n+y] == *(array+x*n+y), wether array[x][y] == *(*(array+x)+y), so you have one multiplication less, but one dereferenciation more, in sum I think it's quicker.

You could also create a class:

class array2d
{
private:
    int *data;
    int mm, nn;
public:
    array2d (int m, int n)
    {
        mm = m;
        nn = n;
        data = new int [m*n];       
    }
    ~array2d ()
    {
        delete[] data;
    }
    int *operator[] (int x)
    {
        return (data+x*nn);
    }
};

With it you can use

array2d arr(10,10);
arr[5][7] = 1;

Answer 6

Firstly I suggest you should use std::vector to avoid memory allocation / deallocation issues.

In case you want an array implementation, then you can declare array as a pointer to pointer to int.

cin >> m >> n;
int** array = new int* [m];
for ( int I = 0; I < m; I++ ) {
  array[I] = new int[n];
}