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

【问题标题】：Dynamic arrays of objects/classes in C++C++ 中的对象/类的动态数组
【发布时间】：2013-01-11 23:23:50
【问题描述】：

我会切入正题，以免大家对多余的阅读感到无聊：

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

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

所以我的问题是：

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

比如

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

非常感谢您提供一个超级简短的示例和类似的解释。 =)

【问题讨论】：

那么……你不懂指针指向的指针吗？是这样吗？
如果这就是所谓的，那么是的。
X *x 是一个指针。 X **x 是指向指针的指针。 X **x[10] 是一个包含 10 个指针的数组。现在您知道了，如果没有，您至少知道要搜索什么。
@user1770094：获取我们的recommended beginner C++ books 之一并开始阅读。在此期间（以及之后永远）使用std::vector<> 来满足您的动态数组需求。
如果你了解指针，那么指向指针的指针并不复杂。

标签： c++ arrays object pointers dynamic

【解决方案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];

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

【讨论】：

但是这个问题有一个双指针数组（多了一层间接性）。
@BenVoigt：是的，但我希望一旦理解了指向 X 的指针的概念，下一步应该很容易。在我的脑海中，我也没有那个级别的好例子。 ;)

【解决方案2】：

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

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** 都是指向特定@ 的指针987654331@指针。

【讨论】：

总结得非常好。我现在掌握了窍门。但现在我想知道为什么有人会使用更多的指针。这解决了什么样的问题/这通常是为了什么？
就像我说的，如果不知道使用它的上下文，就很难确定。通常使用指针对指针，例如创建对象指针的动态数组。但是指针到指针的数组并不常用。它可以用于一个领域是查找表。在这种情况下，foo 可以是一个包含 10 个项目的数组，最初包含指向存根指针的指针，然后可以在应用程序生命周期的稍后时间换出指向存根的值，而无需更改数组的内容本身。

【解决方案3】：

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

如果您定义一个指向指针的数组，例如在“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];

无论你想如何使用你的内存，最终都归结为一些内存地址及其内容。

【讨论】：

【解决方案4】：

TheClass** foo[10];

这行代码告诉编译器创建一个名为 foo 的数组，该数组包含 10 个 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

【讨论】：