需要有关C++中二维数组的动态内存分配的帮助

代码只使用一个内存块来表示所有元素，因此要访问示例( i, j )，需要计算索引为i * num_rows + j（或num_colums，具体取决于您如何看待它）。

但正如所评论的，不要使用new int....，使用类似的东西

std::vector< int > a( m * n );

首先，您要做的是将1添加到一维数组的不同槽中。

以下是您代码的注释版本：

int *a = new int[m*n];  // declares a pointer a, that points to a newly 
                        // allocated space on the heap, for an array of size m*n.

for( int i = 0 ; i < m ; i++)        // loop through m number of times
    for ( int j = 0 ; j < n ; j++)   // loop through n number of times PER m
             a[i*n + j] = 1;         // assigns 1 to a spot [i*n + j]

这就是制作动态2D数组（换句话说，指向数组的指针数组）的方法：

const int sizeX = 10;
const int sizeY = 5;
int** arrayOfPointers = new int*[sizeX];
for(int i = 0; i < sizeX; i++)
    arrayOfPointers[i] = new int[sizeY];

然后，您可以使用双环（NOT TESTED）将多个元素添加到该数组中：

for(int i = 0 ; i < sizeY ; i++)        // loop through all the rows
    for (int j = 0 ; j < sizeX ; j++)   // loop through all columns for row i
         arrayOfPointers[i][j] = i*j; // assigns i*j to a spot at row i, column j

这就是如何打印出2D阵列的内容：

for(int i = 0 ; i < sizeY ; i++) { 
    for (int j = 0 ; j < sizeX ; j++)   
         cout << arrayOfPointers[i][j];
    cout << endl; // go to the next line when the row is finished
}

首先，让我指出这不是一个二维数组，而是一个一维数组。您可以看到int* a = new int[ m*n ]为大小为m*n的整数分配了一个数组。

要获得二维数组，可以使用int** a = new int*[m]。请注意此处使用的两个星号（*）。分配了数组的"第一个"维度后，您现在必须通过分配第二个维度

for( int i = 0; i < m; i++ )
{
   a[i] = new int[n];
}

然后，您可以在m和n上循环，并使用a[i][j]访问数组内容。

使用C++中的STL，您可以通过使用二维向量来获得二维数组，如：

std::vector< std::vector<int> > array( rows,
                                       std::vector<int>( columns ) );

这将分配包含整数的二维向量，其中rows元素在第一维度，columns元素在第二维度。这样的使用有时是不受欢迎的，但std::vector为您管理内存，这可能很好。

尽管Paul R说过我完全支持的话，但上面代码中的注释是错误的，您不能使用a[m][n]对已分配为一维内存的数组进行正确寻址。

如果真的必须在不使用C++标准容器（如向量或数组）的情况下工作，那么你能做的就是分配整个块，然后将地址存储到行的开头

int** createTwoDimMatrix(unsinged int rows, unsigned int columns)
{
    int** rowAdressTable = new int*[rows];
    int*  baseMemory = new int[rows*columns];
    //fill the rowAddressTable
    for(unsinged int r=1; r<rows; ++r)
    {
         rowAdressTable[r] = rowsAdressTable[r-1]+columns*sizeof(int)
    }
    return rowAdressTable;
}

但让我重复一遍：请考虑使用C++容器

对于内存，无论你有什么类型的数组，它们都存储在一个内存块中，可以可视化为1d数组。

在本例中，由于要对m x n阵列进行塌陷，因此需要放置m*n大小的块。这种方法与其他方法的区别在于，现在您必须将数组访问为1d。

例如，具有以下2d阵列：

1 2 3
4 5 6
7 8 9

它将按如下方式存储在存储器中：

1 2 3 4 5 6 7 8 9

我想你可以看到模式：为了从你的2d数组中访问a[i][j]，1d的等价物应该是a[i*dim+j]，其中dim是你的行的长度。

你访问数组的方式完全取决于你分配它的方式。为了能够直接访问arr[i][j]元素，你必须分配如下的内存：

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

这将创建一个n x m阵列。