int **arr = new int* [NoOfRows]
for(int i = 0; i<NoOfRows; i++)
   arr[i] = new int[noOfColumn];

这是在c++中使用new声明2D数组的好方法 这里，NoOfRow显示了你需要多少行 ans noOfColumn显示你需要多少列

在c++ 11及以上版本中，我推荐两种通用技术，一种用于编译时维度，另一种用于运行时维度。这两个答案都假设您需要统一的二维数组(而不是锯齿状数组)。

编译时维度

使用std::array的std::array，然后使用new把它放到堆上:

// the alias helps cut down on the noise:
using grid = std::array<std::array<int, sizeX>, sizeY>;
grid * ary = new grid;

同样，这仅适用于在编译时已知维度大小的情况。

运行时维度

实现只有在运行时才知道大小的二维数组的最佳方法是将其包装到一个类中。该类将分配一个1d数组，然后重载操作符[]来为第一个维度提供索引。 这是因为在c++中，2D数组是行为主的:

(摘自http://eli.thegreenplace.net/2015/memory-layout-of-multi-dimensional-arrays/)

连续的内存序列有利于提高性能，而且易于清理。下面是一个示例类，省略了很多有用的方法，但显示了基本思想:

#include <memory>

class Grid {
  size_t _rows;
  size_t _columns;
  std::unique_ptr<int[]> data;

public:
  Grid(size_t rows, size_t columns)
      : _rows{rows},
        _columns{columns},
        data{std::make_unique<int[]>(rows * columns)} {}

  size_t rows() const { return _rows; }

  size_t columns() const { return _columns; }

  int *operator[](size_t row) { return row * _columns + data.get(); }

  int &operator()(size_t row, size_t column) {
    return data[row * _columns + column];
  }
}

因此，我们用std::make_unique<int[]>(行*列)项创建一个数组。我们重载操作符[]，它将为我们索引行。它返回一个int *，指向该行的开头，然后可以像对列一样对该行进行解引用。注意，make_unique在c++ 14中首次发布，但如果需要，可以在c++ 11中填充它。

对于这些类型的结构，重载operator()也是很常见的:

  int &operator()(size_t row, size_t column) {
    return data[row * _columns + column];
  }

从技术上讲，我在这里没有使用new，但是从std::unique_ptr<int[]>移动到int *并使用new/delete是很简单的。

如果你想声明一个预定义的指针数组:

int **x;
x = new int*[2] { 
        new int[2] { 0, 1 },
        new int[2] { 2, 3 } 
    };

访问:

cout << x[0][0];

在c++ 11中可以:

auto array = new double[M][N]; 

这样，内存就不会被初始化。要初始化它，可以这样做:

auto array = new double[M][N]();

示例程序(用"g++ -std=c++11"编译):

#include <iostream>
#include <utility>
#include <type_traits>
#include <typeinfo>
#include <cxxabi.h>
using namespace std;

int main()
{
    const auto M = 2;
    const auto N = 2;

    // allocate (no initializatoin)
    auto array = new double[M][N];

    // pollute the memory
    array[0][0] = 2;
    array[1][0] = 3;
    array[0][1] = 4;
    array[1][1] = 5;

    // re-allocate, probably will fetch the same memory block (not portable)
    delete[] array;
    array = new double[M][N];

    // show that memory is not initialized
    for(int r = 0; r < M; r++)
    {
        for(int c = 0; c < N; c++)
            cout << array[r][c] << " ";
        cout << endl;
    }
    cout << endl;

    delete[] array;

    // the proper way to zero-initialize the array
    array = new double[M][N]();

    // show the memory is initialized
    for(int r = 0; r < M; r++)
    {
        for(int c = 0; c < N; c++)
            cout << array[r][c] << " ";
        cout << endl;
    }

    int info;
    cout << abi::__cxa_demangle(typeid(array).name(),0,0,&info) << endl;

    return 0;
}

输出:

2 4 
3 5 

0 0 
0 0 
double (*) [2]

这个问题一直困扰着我——这是一个很常见的问题，应该已经有了一个好的解决方案，比向量的向量或滚动你自己的数组索引更好的解决方案。

当c++中应该存在一些东西，但却不存在时，第一个地方是boost.org。在那里我找到了Boost多维数组库，multi_array。它甚至包括一个multi_array_ref类，可用于包装您自己的一维数组缓冲区。

在某些情况下，我给你留下了一个最适合我的解决方案。特别是如果一个人知道[的大小?数组的一维。对于字符数组非常有用，例如，如果我们需要一个大小不同的字符数组[20]。

int  size = 1492;
char (*array)[20];

array = new char[size][20];
...
strcpy(array[5], "hola!");
...
delete [] array;

键是数组声明中的括号。