C++ 在C++；

当我创建一个整数指针数组时，我尝试了这个方法

int *arr = new int*[10];

这不起作用，但以下方法起作用

int **arr = new int*[10];

为什么我们需要双指针？？当我尊重它的时候，我必须做以下的事情

cout<<arr[0];

cout您不仅仅是“创建整数指针数组”：您是在动态分配它们

就像动态分配整数数组一样，您可以通过一个指针访问它们：

int* ptr = new int[5];

当您将一个指针数组动态分配给integer时，您也可以通过一个指针访问这些指针；由于您的元素类型是
int*
，添加额外的
*
将为您提供
int**
：

int** ptr = new int*[5];

至于解引用，我不太清楚您在问什么，但这就是
[]
操作符的工作原理；它将
n
添加到指针，然后取消引用它：

int* ptr = new int[5];
*(ptr+1) = 42;         // identical
  ptr[1] = 42;         // to this


如果您忘记了动态分配，只是创建了一个漂亮的数组，那么一切都会简单得多：

int* array[5];
std::cout << array[0];

int*数组[5]；
std：：cout您不仅仅是“生成整数指针数组”：您是在动态分配它们

就像动态分配整数数组一样，您可以通过一个指针访问它们：

int* ptr = new int[5];

当您将一个指针数组动态分配给integer时，您也可以通过一个指针访问这些指针；由于您的元素类型是
int*
，添加额外的
*
将为您提供
int**
：

int** ptr = new int*[5];

至于解引用，我不太清楚您在问什么，但这就是
[]
操作符的工作原理；它将
n
添加到指针，然后取消引用它：

int* ptr = new int[5];
*(ptr+1) = 42;         // identical
  ptr[1] = 42;         // to this


如果您忘记了动态分配，只是创建了一个漂亮的数组，那么一切都会简单得多：

int* array[5];
std::cout << array[0];

int*数组[5]；
std:：cout
newint*[10]
分配一个包含十个指针的数组，并生成指向该数组第一个元素的指针。元素类型本身就是一个指针，这就是为什么最终会有一个指向指针的指针（指向
int
），即
int**
。显然，
int**
不能转换为
int*
，因此必须使用适当的类型声明
arr
。
new int*[10]
分配一个包含十个指针的数组，并生成指向该数组第一个元素的指针。元素类型本身就是一个指针，这就是为什么最终会有一个指向指针的指针（指向
int
），即
int**
。显然，
int**
不能转换为
int*
，因此必须使用适当的类型声明
arr
。
此语句是int的1D数组的表达式

int* arr = new int [10]; // pointer to array of 10 int

int** arr = new int* [10]; // pointer to 10 pointers to arrays of 10 int

此语句是int的2D数组的表达式

int* arr = new int [10]; // pointer to array of 10 int

int** arr = new int* [10]; // pointer to 10 pointers to arrays of 10 int

要填充1D数组，您需要执行以下操作

for (int i = 0; i < 10; i++) {
        arr[i] = val; // where val can be any integer
}

int** arr2 = new int*[10];
for (int i = 0; i < 10; i++) {
    arr2[i] = new int[10];
    for (int j = 0; j < 10; j++) {
        arr2[i][j] = val; // where val can be any integer
    }
}

for（int i=0；i<10；i++）{
arr[i]=val；//其中val可以是任意整数
}

要填充二维阵列，需要执行以下操作

for (int i = 0; i < 10; i++) {
        arr[i] = val; // where val can be any integer
}

int** arr2 = new int*[10];
for (int i = 0; i < 10; i++) {
    arr2[i] = new int[10];
    for (int j = 0; j < 10; j++) {
        arr2[i][j] = val; // where val can be any integer
    }
}

int**arr2=新int*[10]；
对于（int i=0；i<10；i++）{
arr2[i]=新整数[10]；
对于（int j=0；j<10；j++）{
arr2[i][j]=val；//其中val可以是任意整数
}
}

变量类型和变量名称之间的*符号是指针的语法。它将类型从int更改为int指针。
此语句是int的1D数组的表达式

int* arr = new int [10]; // pointer to array of 10 int

int** arr = new int* [10]; // pointer to 10 pointers to arrays of 10 int

此语句是int的2D数组的表达式

int* arr = new int [10]; // pointer to array of 10 int

int** arr = new int* [10]; // pointer to 10 pointers to arrays of 10 int

要填充1D数组，您需要执行以下操作

for (int i = 0; i < 10; i++) {
        arr[i] = val; // where val can be any integer
}

int** arr2 = new int*[10];
for (int i = 0; i < 10; i++) {
    arr2[i] = new int[10];
    for (int j = 0; j < 10; j++) {
        arr2[i][j] = val; // where val can be any integer
    }
}

for（int i=0；i<10；i++）{
arr[i]=val；//其中val可以是任意整数
}

要填充二维阵列，需要执行以下操作

for (int i = 0; i < 10; i++) {
        arr[i] = val; // where val can be any integer
}

int** arr2 = new int*[10];
for (int i = 0; i < 10; i++) {
    arr2[i] = new int[10];
    for (int j = 0; j < 10; j++) {
        arr2[i][j] = val; // where val can be any integer
    }
}

int**arr2=新int*[10]；
对于（int i=0；i<10；i++）{
arr2[i]=新整数[10]；
对于（int j=0；j<10；j++）{
arr2[i][j]=val；//其中val可以是任意整数
}
}

变量类型和变量名称之间的*符号是指针的语法。它将类型从int更改为int指针。
这是什么“这不起作用”？你对“成功”的定义是什么？请使用精确的语言。我们在这里是科学家。
int*
指向
int
或
int
数组的第一个元素。如果你想指向一个
int*
而不是
int
，你需要
int**
（指向int指针或指向int指针数组的第一个元素的指针）。“我必须做以下事情。”-奥莉？我肯定不是科学家。这是什么“这不起作用”？你对“成功”的定义是什么？请使用精确的语言。我们在这里是科学家。
int*
指向
int
或
int
数组的第一个元素。如果你想指向一个
int*
而不是
int
，你需要
int**
（指向int指针或指向int指针数组的第一个元素的指针）。“我必须做以下事情。”-奥莉？我绝对不是科学家。