1

我会切入正题，为大家省去一些无聊的多余阅读：

我试图在互联网上搜索关于对象/类的动态数组的教程，其中解释了如何在此处实现指针。特别是：TheClass **foo[10];或类似的东西，我不明白两颗星/星号有什么好处以及它们是如何使用的。总的来说，这整个事情。

我确实知道如何声明动态数组，如何使用常规指针，如何制作类，如何制作类的动态数组。但这一切加在一起让我感到困惑。

所以我的问题是：

  1. 这是做什么的，它是如何工作的？

  2. 你能推荐一个你知道可以找到示例/教程的网站吗？

  3. 这是否具有特定名称而不是“具有双指针的动态对象数组”或诸如此类的名称？

  4. 如果没有想到教程，如果您能举一个非常非常简短的示例，我将不胜感激。

比如像

int *something;
int somethingElse = 10;
something = &somethingElse; /*Now when you change "somethingElse","something" 
                              will also change to the same number*/

一个超级简短的例子和这样的解释将不胜感激。=)

4

4 回答 4

2

使用指向指针的指针的最简单、或多或少有用的示例是二维数组。所以例如

//Create a pointer to (an array of) pointers to (an array of) ints
int** array2D;

//Create a array of pointers to (an array of) ints and assign it to the pointer
array2D = new int*[10];

//Assign each of the pointers to a new array of 10 ints
for(size_t i =0; i<10;i++) {
    array2D[i] = new int[10];
}

//Now you have an 2 dimensional array of ints that can be access by
array2D[1][3] = 15;
int test = array2D[1][3];

我希望这能解释一下指向指针的指针是什么以及它们是如何工作的。

于 2013-01-11T23:41:53.457 回答
1

好吧，我看到你的目标是完整的答案，我会给出一个简短的例子。

如果您定义一个指向指针的指针数组，例如在“class foo**[10]”示例中，假设：

int numX = 100;
int numY = 1000;

Node **some[10];
    some[0] = new Node*[numX];
    some[0][0] = new Node[numY];

那么它的意思是：

您的第一级有 10 个节点**。因此，您有 10 个指向 Node** 类型的指针，但它们还没有指向任何有用的地方。

这只是用于存储指针的 10 个相邻内存位置。在这种情况下，它们指向的内容无关紧要，主要是它只是 10 个包含指针空间的字段。

然后取这 10 个“空格”中的第一个，并将 100 个指针数组的地址分配给类型 Node*

some[0] = new Node*[numX]; //numX = 100

这是在运行时完成和评估的，因此您可以使用用户输入或某些应用程序逻辑给出的变量值来定义数组的维度，即内存字段。

现在您有 10 个指针中的 1 个指向 100 个指向 Node* 类型的指针，但仍然指向一个黑洞。

在最后一步中，创建 1000 个 Node 类型的对象，并将它们的地址附加到 100 个指针中的第一个。

some[0][0] = new  Node[numY]; //numY = 1000

在上面的示例中，这意味着只有 [0][0][0] 到 [0][0][999] 是对象，您创建的 1000 是：

这样您就可以构建具有指定类型的多维数组。使整个事情奏效的原因是您在最后一个维度 (3) 中实例化您需要的内容并创建指针以唯一索引从 [0][0][0] 到 [9][99][999] 创建的每个字段.

some[0][1]; // memory violation not defined
some[0][0]; // good -> points to a *Node 
some[0][0][0]; // good -> actually points to Node (data)
some[1][0][0]; // memory violation not defined

据我所知，您通常使用一维数组和一些小数学来模拟二维数组。就像说元素 [x][y] = [x+y*width];

无论你想使用你的记忆，最终这一切都归结为一些记忆地址及其内容。

于 2013-01-12T00:03:14.963 回答
1

指针就是指针。它指向某物。时期。如果你理解了这么多，那么你应该能够理解指向指针的指针是什么。它只是一个指针，其值是另一个变量的内存地址，该变量本身就是指向其他东西的指针。就这样。每次添加 a*时，它只是另一个级别的指针间接。例如：

int i;
int* p_i = &i; // p_i is a pointer to an int and points at i
int** pp_i = &p_i; // pp_i is a pointer to an int* and points at p_i
int*** ppp_i = &pp_i; // ppp_i is a pointer to an int** and points at pp_i

现在将该概念应用于TheClass **foo[10];（实际上是TheClass** foo[10];从编译器的角度来看）。它声明了一个名为的数组foo，其中包含 10 个TheClass**指向指针的元素。每个都TheClass*可能是指向特定TheClass对象的指针，也可能是TheClass元素的动态数组（没有更多上下文无法知道），然后每个TheClass**都是指向特定指针的TheClass*指针。

于 2013-01-12T00:03:38.527 回答
0 
TheClass** foo[10];

这行代码告诉编译器创建一个包含foo10 个类型元素的数组pointer to (pointer to Theclass )。

通常，当您想找出涉及多个星号、& 符号的类型时。从左到右阅读。所以我们可以把上面的代码分解成这样：

   (  (Theclass)  *  )  *  foo[10] 
          ^       ^     ^    ^   ^
          5       4     3    2   1

#1 an array of 10 elements named #2 foo #3 of type pointer #4 to pointer #5 to Theclass
于 2013-01-11T23:40:09.797 回答