看来你需要一对一。编辑：好吧，更确切地说，下面的例子创建了 * 一个指向数组的指针数组 *。
第一步：

int **p = new int*[NUM];

字符串
这里你已经创建了一个指针数组。现在您需要为它们中的每一个创建另一个数组。你可以这样做：

for(int i = 0; i < NUM; i++)
{
    p[i] = new int[ANOTHER_NUM];
}

型
对于释放，您可以执行类似的操作，但以相反的方式执行：

for(int i = 0; i < NUM; i++)
{
    delete[] p[i];
}

型
最后：

delete[] p;

型
现在你可以使用它。这样就可以创建N维数组，只需添加更多的'*'。如果你有任何其他特别的问题，请在评论中提出。
但是，一般来说，为了进一步的信息，我建议你先尝试谷歌的问题，如“2D数组在C++”或“动态分配2D数组C++”，即。即this query。

其他答案包括为您的行设置一个指针数组，每行指向一个int数组的指针。另一种选择是简单地分配一个足够大的一维数组来容纳所有二维数组的元素：

int* p = new int [3 * 4];

字符串
然后使用p[r * kNumCols + c]而不是p[r][c]语法。在这个例子中，kNumCols = 4。这通常是LAPACK风格的数字运算所做的，因为它使内存中的内容保持连续，并且不需要分配这么多内存块。
注意：在实践中，这通常 * 不 * 比替代方案慢，因为行偏移计算被公共子表达式优化移出了循环。此外，许多优化器都知道寻找这种模式。此外，通过将数据放在单个内存块中，数据更有可能留在缓存中。
在C++中，你可以用一个helper模板类来实现p[][]符号：

template<class T>
class Array2DPtrRow
{public:
    Row(T* row_): row(row_) {}
    operator T*() { return row; }
    T& operator [](size_t c) { return row[c]; }
private:
    T* row;
};

template<class T, size_t NC>
class Array2DPtr
{public:
    Array2DPtr(T* buf_): buf(buf_) {}
    operator T*() { return buf; }
    Array2DPtrRow<T> operator [](size_t r)
        { return Array2DPtrRow<T>(buf + NC * r); }
private:
    T* buf;
};

型
这优化到与上面相同的代码，但允许您使用[][]表示法，并且 * 要求您在编译时知道数组的维数 *。使用示例：

Array2DPtr<int, 4> p(new int[3 * 4]);
p[1][2];

型
这可以转换为NC成为类成员而不是模板参数，但最终对象不再只是指针：

template<class T>
class Array2DPtr
{public:
    Array2DPtr(T* buf_, size_t nc_): buf(buf_), nc(nc_) {}
    operator T*() { return buf; }
    Array2DPtrRow<T> operator [](size_t r)
        { return Array2DPtrRow<T>(buf + nc * r); }
private:
    T* buf;
    size_t nc;
};

Array2DPtr<int> p(new int[3 * 4], 4);
p[1][2];

型
请注意，这些类都不需要复制构造函数、赋值运算符或析构函数，因为它们不像常规指针那样拥有所指向内存的所有权。所以要释放内存，你仍然需要做：

delete[] p;

型
或者如果你的编译器不能解决这个问题：

delete[] (int*)p;

型

来回答这个问题
记住，一个数组相当于一个指向数组第一个元素的指针，所以例如你可以写：

char str[14] = "Hello, world!";
char *ptr = str;

字符串
这也适用于二维数组。

int (*p)[4];

型
声明指向二维数组第一个元素的指针。然后p可以指向任何二维数组，只要它的第二个维度是4，所以例如你可以写

int arr[3][4];
int (*p)[4] = arr;

型
当然，你也可以动态地分配内存：

int (*p)[4] = new int[3][4];

型
同样，第二个维度必须是4，但您可以改变第一个维度。

在C中有几种声明多维数组的方法。
可以将p显式声明为2D数组：

int p[3][4];  // All of p resides on the stack.

字符串
(Note new在这里对于基本类型是不需要的，除非你使用的是C++并且想在堆上分配它们。
或者你可以将它声明为指针的向量（1D数组），然后为每个向量分配内存：

int *p[3];                         // The vector addresses reside on the stack.
for (int i=0; i<3; i++) {
  p[i] = malloc(4 * sizeof(int));  // Each element resides on the heap.
}

// You can now access p as p[j][k] as if it were a 2D array.

for (int i=0; i<3; i++) {
  free p[i];
}

型
或者，如果你不知道任何一个维度，你可以动态分配整个2D数组：

#define WIDTH 3
#define HEIGHT 4
int **p;                              // Base address resides on the stack.

p = malloc(WIDTH * sizeof(int *));    // Pointers to vectors reside on the heap.
for (int i=0; i<WIDTH; i++) {
  p[i] = malloc(HEIGHT * sizeof(int)); // Data values reside on the heap.
}

// You can now access p as p[j][k] as if it were a 2D array.

// Release the memory that was allocated to each vector.
for (int i=0; i<WIDTH; i++) {
  free(p[i]);
}
// Release the memory that was allocated to the initial pointer.
free(p);

型

你需要这样的东西

int **array_ptr; //two * are needed because it is a pointer to a pointer

array_ptr=new int*[firstnumber]; //creates a new array of pointers to int objects

for(int i=0; i<firstnumber; ++i)
array_ptr[i]=new int[secondnumber];

字符串

已经有一个很好的答案了，但是我想在不使用（new，delete）的情况下分配一个2d数组。所以我使用了std：：vector。

std::vector<std::vector<double>> A;
    A.resize(Col);

    for(int i=0; i<Col; i++)
    {
        A[i].resize(Row);
    }

字符串