3

我对指向指针的指针有点困惑，并且由于 Google 省略了一些符号而无法找到所需的结果。下面的陈述实际上是什么意思

int** arr[10];

它是 10 个双指针数组还是指向 10 个整数指针数组的指针（或两个语句相同）。

下面的陈述描述了什么？

*arr[0] = new int(5); //assign the first pointer to array of 10 pointers a memory of 5?

并且是第一个语句等价于

int* (*arr)[10];

如果有人能解开我的疑虑，将不胜感激。谢谢！

4

5 回答 5

7

下面的陈述实际上是什么意思

这意味着指向指针的指针数组int。数组中正好有 10 个元素，每个元素的类型为int**.

下面的陈述描述了什么？

它首先访问数组中的第一个元素，然后取消引用它以访问int*. 第一个元素指向的 int 指针被赋值为指向新分配的内存。新分配的内存的值为5。

并且是等价于 int* (*arr)[10] 的第一条语句；

一点都不。int* (*arr)[10];是一个指向数组的指针int*。换句话说，它不是一个数组，它是一个指向数组的指针，它指向的数组包含 10 个元素，它们都是int*.

于 2013-07-01T05:32:17.847 回答
3

该[]符号优先于*您进行声明时。所以像

int* arr[10];

实际上是一个由 10 个指向整数的指针组成的数组，尽管从左到右读取它自然看起来像一个指向数组的指针。

但是，如果您像这样调整优先级：

int (*arr)[10];

你得到一个指向十个整数数组的指针。

在您的情况下int** arr[10];，是一个由 10 个指针组成的数组。并且它不等同于int* (*arr)[10];后者是指向 10 个整数指针数组的指针（基本上在前一种情况下你有一个数组，而在后者中是一个指针，这是一个非常重要的区别）。

也许 C++ 专家可以回答您关于new.

于 2013-07-01T05:31:39.123 回答
3 
35 <---- I am a pointer to an int


35 <---- I am pointer to an int <---- I am a pointer to an int pointer

这段代码：

int** arr[10];

在最右边声明一个由 10 个指针组成的数组。

int** arr[10];

int num = 35;
int* pint = &num;
int** ppint = &pint;
arr[0] = ppint;

int** ppint2 = new int*[5];
int num2 = 35;
int num3 = 45;
*ppint2 = &num2;
*(ppint2 + 1) = &num3;
cout << **ppint2 << " " << **(ppint2 + 1) << endl;

--output:--
35 45


int* pint2 = new int[3];
int* pint3 = new int[2];

*pint2 = 10;
*(pint2 + 1) = 20;
*(pint2 + 2) = 30;

*pint3 = 100;
*(pint3 + 1) = 200;

arr[0] = &pint2;
arr[1] = &pint3;

cout << **arr[0] << endl;
cout << *(*arr[0] + 1) << endl;

--output:--
10
20

Apointer是存储内存地址的变量。因此，假设您将 int 10 存储在地址 1A 中。您可以创建一个指向 10 的指针变量，指针变量的值为 1A。当然，指针的值必须存储在内存中的某个位置，因此您可以创建另一个指针来存储第一个指针的值在内存中的位置。您可以通过将第一个指针的地址分配给第二个指针来实现。第一个指针的类型是int*，第二个指针的类型是int**，即第二个指针是一个指针，存放的是一个int指针的地址。

*arr[0] = new int(5);

arr[0] 是一个存储其他指针所在地址的指针
*arr[0] 说，“请获取另一个指针”
*arr[0] = new ... 将 new 返回的地址分配给另一个指针。

于 2013-07-01T05:40:45.643 回答
2

好的，让我们一次回答一个问题。

int** arr[10];是一个包含 10 个指针的数组，它们指向整数指针。C++ 中的声明通常可以从右到左更容易地阅读。请注意，这arr是一个数组，而不是指针——尽管它可以“衰减”为指向其元素的指针（类型为int***）。

*arr[0] = new int(5);涉及几个步骤。首先，在堆上分配一个整数（就是这样new做的）。它用值 5 初始化（该(5)位称为 的“构造函数” int）。new返回一个指针 ( int*)，指向这个新分配的 int 在内存中的位置。该指针被分配给 arr 中第一个指向指针的指针所指向的指针——*取消引用分配的第一个元素。

int* (*arr)[10];有点异国情调，并不等同；它似乎声明了一个指向 10 个 int 指针数组的指针（source）。

于 2013-07-01T05:31:13.143 回答
2

破译这样的陈述的一个好技巧是逐步进行并建立

这是一个双打数组

double array[5];

array 也是一个指针，所以这是相同的（但是第一个已知大小为 5，第二个它可以指向任何数字）

double *array;

`

现在让我们尝试一些更通用的东西

T *a;是指向一个或多个 Ts 的指针，所以T a[x];x 是一个数字

这里建立T **a;的 a 是一个指向一个或多个指向一个或多个 Ts 的指针

这意味着它*a是一个指向一个或多个 T 的指针以及类似的东西

*a = new T[5]是有效的，但a = new T[5]不是正确的，它会a= new T*[5]创建 5 个指向 Ts 的指针

所以回到你原来的例子int ** arr[10]; ，这里 arr 指向一个 10 int ** 的静态数组，这意味着arr[0] = new int*[5]是一个有效的语句，以下是有效的 C++

    int ** arr[10];

arr[0] = new int*[5];
arr[0][1] = new int[5];
arr[0][1][0] = 4;

std::cout << arr[0][1][0] << std::endl; // prints 4

delete [] arr[0][1];
delete [] arr[0];
    //note that arr doesn't need to be deleted as it wasn't dynamically allocated
于 2013-07-01T05:55:32.733 回答