C++ 多维动态数组，为什么'；这不管用吗？

我不是在这里寻找解决方案，我在谷歌上找到了很多。我在找一个解释

在使用数组时，我发现动态声明2D数组并不像预期的那样工作

1D阵列，工作正常

int main()
{
int rows;
int* pointer;
pointer = new int[rows]; 
}

2D阵列，不工作

int main()
{
int rows;
int columns;
int* pointer;
pointer = new int[rows][columns]; //error on this line
}

在我看来，这似乎是一种直观的处理方式，因为这是使用常规数组的方式，但显然它是不正确的，无法编译

我还没有找到一个明确的解释，为什么会出现这种情况，希望这里有人能启发我

---

谢谢：）

您可以通过以下方式理解它：

二维数组看起来像一个网格，有行和列用于人类表示，但在内存中它存储在连续内存中。因此，每当你说二维数组或大小

mxn

时，你指的是

m

数组中的

n

元素一个接一个地存储。i、 e.对于3x3，网格元素存储为：

(0,0) (0,1) (0,2) (1,0) (1,1) (1,2) (2,0) (2,1) (2,2)

如果要访问这样的数据结构，需要使用指向指针的指针，即指向每行第一个元素位置的地址数组的指针

因此，可以通过3个（行数）地址访问阵列

(Address of element 0,1) (Address of element 1,0) (Address of element 2,0)

由于元素的地址是存储的，所以现在您需要一个指向指针的指针来访问指针数组（保存每行第一个元素的地址）

对于1D阵列：

int* pointer = new int[3];

Array: (0) (1) (2)
pointer: (Address of first element of Array)

对于二维阵列：

int **pointer = new int[3][3];

Array: (0,0) (0,1) (0,2) (1,0) (1,1) (1,2) (2,0) (2,1) (2,2)
Row Address Array: (Address of 0,1) (Address of 1,0) (Address of 2,0)
pointer: (Address of first element of Row Address Array)

---

希望这有帮助

这不起作用的原因是，为了能够拥有一个二维数组，您需要一个指针数组，它将指向您想要的许多类型的数组

在本例中，您试图将地址存储到int*类型的变量中的int*数组（其中每个“单元格”将指向一个int数组），它应该是int**

重述： 1D数组：int* 二维数组：int** 三维数组：int***

---

所有数组都必须是一维的原因是因为您的内存是一维的（将所有内存视为一个大的内存地址数组），这意味着多维数组必须是“伪造的”。

其他人对此进行了很好的解释，但这里有一个示例，可以帮助您使用

new

创建动态大小的多维数组：

int rows = 20;
int columns = 30;

// the following is essentially just an array of int pointers
int **pointer = new int*[rows]; 

// so, loop through the array creating the second dimension
for (int i = 0;i < rows;i++)
    pointer[i] = new int[columns];

int行=20；
int列=30；
//以下内容本质上只是一个int指针数组
int**指针=新int*[行]；
//因此，在数组中循环创建第二个维度
对于（int i=0；i

这不仅仅是其他答案中描述的数据类型问题。

语法类似于

pointer = new int[rows][columns]

仅当

列

是常量表达式时才有效。这里不能使用变量（但请注意，

行

可以是变量）

这是解释。C++标准使您可以用下面的方式使用< <代码> < <代码> >运算符的二维数组语法（仅从5.3.4／1）：

相关部分如下所示：

noptr-new-declarator:
  [ expression ] attribute-specifier-seqopt
  noptr-new-declarator [ constant-expression ] attribute-specifier-seqopt

第一行表示在type-id之后可以有一个括号内的表达式。第二行（递归语句）允许在初始括号之后使用多对括号，但它们必须包含一个常量表达式

本标准进一步解释了这一点（重点）：

（§5.3.4/5）当分配的对象是数组（即使用noptr新声明符语法或新类型id或类型id表示数组类型）时，新表达式生成指向数组初始元素（如果有）的指针。[注意：new int和new int[10]都有int*类型，而new int[i][10]的类型是int（*）[10]-结束注意]noptr new声明符中的属性说明符seq与关联的数组类型相关

（§5.3.4/6）noptr新声明符中的每个常量表达式应为积分常量表达式（5.19），并计算为严格正值。noptr新声明符中的表达式应为整型、非作用域枚举类型或存在到整型或非作用域枚举类型的单个非显式转换函数的类类型（12.3）。[…][示例：给定int n=42的定义，新浮点[n][5]格式正确（因为n是noptr新声明符的表达式），但新浮点[5][n]格式错误（因为n不是常量表达式）。-结束示例]

---

这是一个一维字符指针数组：

char*动态\一维\字符\指针\数组

。注意

字符*

这是一个二维字符指针数组：

char**动态二维字符指针数组

。注意

字符**

这是为二维字符指针数组分配内存的方式：

    //memory allocated for elements of rows.
    Dynamic_Two_Dimensional_Char_Pointer_Array = new char *[ROWS] ;

    //memory allocated for  elements of each column.
    for(   i = 0 ; i < ROWS ; i++ ) Dynamic_Two_Dimensional_Char_Pointer_Array[i] = new char[COLUMNS];

//free the allocated memory
for(   i = 0 ; i < ROWS ; i++ )   delete [] Dynamic_Two_Dimensional_Char_Pointer_Array[i] ;
delete [] Dynamic_Two_Dimensional_Char_Pointer_Array ;

这是如何为二维字符指针数组取消分配内存：

    //memory allocated for elements of rows.
    Dynamic_Two_Dimensional_Char_Pointer_Array = new char *[ROWS] ;

    //memory allocated for  elements of each column.
    for(   i = 0 ; i < ROWS ; i++ ) Dynamic_Two_Dimensional_Char_Pointer_Array[i] = new char[COLUMNS];

//free the allocated memory
for(   i = 0 ; i < ROWS ; i++ )   delete [] Dynamic_Two_Dimensional_Char_Pointer_Array[i] ;
delete [] Dynamic_Two_Dimensional_Char_Pointer_Array ;

//释放分配的内存
对于（i=0；i

完整示例代码：

#include<vector>
#include<string>
#include<iostream>
using namespace std;

int main()
{

    int COLUMNS =80; //80 characters wide
    int ROWS =20;// 20 lines
    int i,maxLines=0;

    char* Dynamic_One_Dimensional_Char_Pointer_Array = new char[80];
    char **Dynamic_Two_Dimensional_Char_Pointer_Array = 0;

    //memory allocated for elements of rows.
    Dynamic_Two_Dimensional_Char_Pointer_Array = new char *[ROWS] ;

    //memory allocated for  elements of each column.
    for(   i = 0 ; i < ROWS ; i++ ) Dynamic_Two_Dimensional_Char_Pointer_Array[i] = new char[COLUMNS];


    strcpy(Dynamic_One_Dimensional_Char_Pointer_Array,"apples 123 oranges 456 bananas 789 lemons 101112 kiwi 132415 grapes 161718" );
    cout<<"  \ninput = "<<Dynamic_One_Dimensional_Char_Pointer_Array<<"  \n\n";
    cout<<"Output = \n";

    char seperators[]   = " ,\t\n";
    char *token; 
   token = strtok( Dynamic_One_Dimensional_Char_Pointer_Array, seperators );  
   i=0;

   while( token != NULL )
   {
      strcpy(Dynamic_Two_Dimensional_Char_Pointer_Array[i],token);
      token = strtok( NULL, seperators );  
      i++;
   }
   maxLines=i;
   cout<<"  \n";

   cout<<"show contents 1 print [rows] \n";
   cout<<"-------------------------------------------\n";
   for(int rows=0;rows<maxLines;rows++)
   {
     cout<<Dynamic_Two_Dimensional_Char_Pointer_Array[rows]<<"  \n";
   }
   cout<<"  \n";

   cout<<"show contents 2  print [rows][columns]\n";
   cout<<"-------------------------------------------\n";

   for(rows=0;rows<maxLines;rows++)
   {
     //cout<<Dynamic_Two_Dimensional_Char_Pointer_Array[rows]<<"  \n";
       for(int columns=0;columns<strlen(Dynamic_Two_Dimensional_Char_Pointer_Array[rows]);columns++)
       {
            cout<<Dynamic_Two_Dimensional_Char_Pointer_Array[rows][columns]<<"";
       }
       cout<<"  \n";
   }



    delete[] Dynamic_One_Dimensional_Char_Pointer_Array;

    //free the allocated memory
    for(   i = 0 ; i < ROWS ; i++ )   delete [] Dynamic_Two_Dimensional_Char_Pointer_Array[i] ;
    delete [] Dynamic_Two_Dimensional_Char_Pointer_Array ;

    return 0;
}

#包括
#包括
#包括
使用名称空间std；
int main（）
{
int COLUMNS=80；//80个字符宽
int ROWS=20；//20行
int i，最大线=0；
字符*动态字符一维字符指针数组=新字符[80]；
字符**动态二维字符指针数组=0；
//为行元素分配的内存。
动态二维字符指针数组=新字符*[行]；
//为每列的元素分配的内存。
对于（i=0；icoutt这不仅仅是数据类型的问题（顺便说一句，数据类型是
int（*）[]
，而不是
int*