Question

我会切断追捕，为你省去一些过剩阅读的无聊：

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

我知道如何声明动态数组，如何使用常规指针，如何创建类，如何创建动态数组类。但所有这些让我感到困惑。

所以我的问题是：

这是做什么的，它是如何运作的？
你能推荐一个你知道可以找到这个例子/教程的网站吗？
这是否具有特定名称而不是“具有双指针的动态对象数组” 还是什么？
如果没有教程，我会很感激，如果你能做一个非常非常简短的例子。

例如

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

一点点超短的例子和这样的解释将不胜感激。 =）

Answer 1

使用指针指针的最简单，或多或少有用的示例将是二维数组。例如，

//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];

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

Answer 2

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

如果你定义一个指向指针的数组，就像在你的“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 *宽度];

但是你想要使用你的记忆，最后它归结为一些记忆地址及其内容。

Answer 3

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

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*指针的指针。

Answer 4

TheClass** foo[10];

这行代码告诉编译器创建一个名为foo的数组，其中包含10个pointer to (pointer to Theclass )类型的元素。

通常，当您想要找出涉及多个astrisks，＆符号的类型时。从左到右阅读。所以我们可以将上面的代码分解为这样的东西：

   (  (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

C ++中动态的对象/类数组

4 个答案: