C++ 为什么我们要使用双指针来引用堆上分配的2D数组？

因此，课程示例包含以下代码

 int **a;
 a = new int*[10];
 for (int i = 0; i < 10; ++i){
      a[i] = new int[5];
      for (int j = 0; j < 5; ++j){
           a[i][j] = i*10+5;
      }
 }

int**a；
a=新整数*[10]；
对于（int i=0；i<10；++i）{
a[i]=新整数[5]；
对于（int j=0；j<5；++j）{
a[i][j]=i*10+5；
}
}

关于上述代码（以及堆上的多维数组），我有几个问题：

我们是否有来初始化数组中的每个元素，如图所示？或者在a[i]=newint[5]之后剪切代码就足够了吗

我知道在堆栈上分配数组时，使用变量作为堆栈大小是非法的

cin>>n

int a[n]

但是，堆分配的数组合法吗？如中所示，a=新整数[n]

为什么它是指向此数组的双指针？通常对于1D数组，我们使用一个指针作为int*a=newint[10]？如果我想要数组元素本身的值，我是否需要两倍于**a的遵从性？还是我现在还在做

比如说，我有一个某类对象的2D数组。如何访问第I个、第j个元素的成员字段var？如果我想调用第I个，第j个元素中对象的成员函数呢

您不必初始化数组中的每个元素。如果不这样做，数组的内容将是未定义的。或者，您可以使用

newint[5]（）

进行零初始化

a=new int[n]

在堆上工作，因为实际上有一个运行时调用来标记新内存，以便在数据

a

指向时使用。它不能在堆栈上工作，因为编译器需要知道任何特定函数调用的堆栈帧有多大，因此该值必须在编译时可计算

您需要一个双指针，因为a是指向整数的指针。它指向一个数组数组，每个数组在访问值时都需要取消引用。您通常会使用[i][j]来访问特定元素，这实际上是双重尊重

您不必初始化数组中的每个元素。如果不这样做，数组的内容将是未定义的。或者，您可以使用

newint[5]（）

进行零初始化

a=new int[n]

在堆上工作，因为实际上有一个运行时调用来标记新内存，以便在数据

a

指向时使用。它不能在堆栈上工作，因为编译器需要知道任何特定函数调用的堆栈帧有多大，因此该值必须在编译时可计算

您需要一个双指针，因为a是指向整数的指针。它指向一个数组数组，每个数组在访问值时都需要取消引用。您通常会使用[i][j]来访问特定元素，这实际上是双重尊重

您不必初始化数组中的每个元素。如果不这样做，数组的内容将是未定义的。或者，您可以使用

newint[5]（）

进行零初始化

a=new int[n]

在堆上工作，因为实际上有一个运行时调用来标记新内存，以便在数据

a

指向时使用。它不能在堆栈上工作，因为编译器需要知道任何特定函数调用的堆栈帧有多大，因此该值必须在编译时可计算

您需要一个双指针，因为a是指向整数的指针。它指向一个数组数组，每个数组在访问值时都需要取消引用。您通常会使用[i][j]来访问特定元素，这实际上是双重尊重

您不必初始化数组中的每个元素。如果不这样做，数组的内容将是未定义的。或者，您可以使用

newint[5]（）

进行零初始化

a=new int[n]

在堆上工作，因为实际上有一个运行时调用来标记新内存，以便在数据

a

指向时使用。它不能在堆栈上工作，因为编译器需要知道任何特定函数调用的堆栈帧有多大，因此该值必须在编译时可计算

您需要一个双指针，因为a是指向整数的指针。它指向一个数组数组，每个数组在访问值时都需要取消引用。您通常会使用[i][j]来访问特定元素，这实际上是双重尊重

---

如果矩阵中的列数在编译时已知，则只需分配一个矩阵：

int nrow = 10;                        // number of rows assigned at run time
int (*a)[5];                          // pointer to array of 5 ints
    a = new int[nrow][5];             // allocate matrix
    for (int i = 0; i < nrow; ++i)    // initialize matrix
        for (int j = 0; j < 5; ++j)
            a[i][j] = i*nrow+j;
    // ...
    delete[] a;

int nrow=10；//运行时分配的行数
int（*a）[5]；//指向5整数数组的指针
a=新整数[nrow][5]；//分配矩阵
对于（int i=0；i

如果矩阵中的列数在编译时已知，则只需分配一个矩阵：

int nrow = 10;                        // number of rows assigned at run time
int (*a)[5];                          // pointer to array of 5 ints
    a = new int[nrow][5];             // allocate matrix
    for (int i = 0; i < nrow; ++i)    // initialize matrix
        for (int j = 0; j < 5; ++j)
            a[i][j] = i*nrow+j;
    // ...
    delete[] a;

int nrow=10；//运行时分配的行数
int（*a）[5]；//指向5整数数组的指针
a=新整数[nrow][5]；//分配矩阵
对于（int i=0；i

如果矩阵中的列数在编译时已知，则只需分配一个矩阵：

int nrow = 10;                        // number of rows assigned at run time
int (*a)[5];                          // pointer to array of 5 ints
    a = new int[nrow][5];             // allocate matrix
    for (int i = 0; i < nrow; ++i)    // initialize matrix
        for (int j = 0; j < 5; ++j)
            a[i][j] = i*nrow+j;
    // ...
    delete[] a;

int nrow=10；//运行时分配的行数
int（*a）[5]；//指向5整数数组的指针
a=新整数[nrow][5]；//分配矩阵
对于（int i=0；i