Malloc结构数组的数组

目标

动态创建元素结构数组的数组（定义如下）

问题

我知道如何对元素结构数组进行malloc

Element* arrayOfElements = malloc(4 * sizeof(Element));

但我该如何对上面的数组进行Malloc呢？（数组元素）

问题2

假设ArrayOfeElements数组称为arrayOfArrayStruc，我如何在其中设置值

例如，我想将65复制到ArrayOfelments[2]，它位于arrayOfArrayStruc内部，我该怎么做

如果我想直接将65条拷贝到ArrayOfelments，我知道该怎么做[2]

arrayOfElements[2].data = malloc( sizeof(int) );
ptr = arrayOfElements[2].data;
*ptr = 65;

但如果arrayOfElements[2]在arrayOfArrayStruc内，我不知道该怎么做

编辑

为了更清楚我的目标，我画了一张图

因此，绿色是由定义的结构元素

typedef struct {
    void* data;
    } Element;

红色（有4个绿色框）是一个元素结构数组，我在malloc中使用了这个数组

Element* arrayOfElements = malloc(4 * sizeof(Element));

我想做的是将上面的^^^存储在一个数组中，或者制作一个指针数组（蓝色框中有红色框）

---

因此，在图中，“元素数组”包含4个元素结构，然后我想创建一个数组来存储4个“元素数组”（或一个由4个指针组成的数组，指向每个“元素数组”）

arrayOfElements

是指针变量的名称。不能有名称数组

您可以有一个指针变量数组。您可以为此编写代码，它与int数组的代码相同，但使用指针类型而不是int。然后，您需要以与现在相同的方式初始化数组中的每个指针变量

然而，如前所述，问题要求的是“数组数组”，而不是“指针数组”。“数组数组”是一个数组，其中元素类型是数组（不是指针）

这是一个非动态分配的数组：

intx[4][5]。这是一个包含4个元素的数组，每个元素都是一个包含5个整数的数组

要动态分配其中一个元素，代码与动态分配任何4个元素的数组相同。我们只是使用
int[5]
作为元素类型，而不是
int
或其他任何类型

指向第一个元素的指针类型是：“指向
int[5]
”的指针。在C语法中，这是写在
int（*）[5]
——而不是
int*[5]
这是一个指针数组

编写代码的一种方法是：

int (*px)[5] = malloc(4 * sizeof(int[5]));

希望您能在问题中看到这与
malloc
之间的相似之处。我们刚刚用
int[5]
替换了
Element
。（因此，您现在的工作是使用
元素[5]
而不是
int[5]
。或者使用任何大小的元素而不是
5
）

为了避免重复（从而避免出错的可能性），可以使用常见的习惯用法：

int (*px)[5] = malloc(4 * sizeof *px);

这是指针所指向的4个元素，每个元素的大小都合适。
arrayOfElements
是指针变量的名称。不能有名称数组

您可以有一个指针变量数组。您可以为此编写代码，它与int数组的代码相同，但使用指针类型而不是int。然后，您需要以与现在相同的方式初始化数组中的每个指针变量

然而，如前所述，问题要求的是“数组数组”，而不是“指针数组”。“数组数组”是一个数组，其中元素类型是数组（不是指针）

这是一个非动态分配的数组：
intx[4][5]。这是一个包含4个元素的数组，每个元素都是一个包含5个整数的数组

要动态分配其中一个元素，代码与动态分配任何4个元素的数组相同。我们只是使用
int[5]
作为元素类型，而不是
int
或其他任何类型

指向第一个元素的指针类型是：“指向
int[5]
”的指针。在C语法中，这是写在
int（*）[5]
——而不是
int*[5]
这是一个指针数组

编写代码的一种方法是：

int (*px)[5] = malloc(4 * sizeof(int[5]));

希望您能在问题中看到这与
malloc
之间的相似之处。我们刚刚用
int[5]
替换了
Element
。（因此，您现在的工作是使用
元素[5]
而不是
int[5]
。或者使用任何大小的元素而不是
5
）

为了避免重复（从而避免出错的可能性），可以使用常见的习惯用法：

int (*px)[5] = malloc(4 * sizeof *px);

这是指针所指向的4个元素，每个元素的大小都合适。
如果需要元素*数组，可以这样做，其中is
n
是指针的数量：

Element** arrayOfStructs = malloc( n* sizeof(Element*) ); 

n=4时也是如此；您将得到一个由4个指针组成的数组：

Element** arrayOfStructs = malloc( n* sizeof(Element*) ); 

阵列结构

+---+
|   | ->
+---+
|   | ->
+---+
|   | ->
+---+
|   | ->
+---+

+---+    +---+---+----+
|   | -> |   |   |    |  array of Elements
+---+    +---+---+----+    +---+---+----+
|   | -------------------> |   |   |    |
+---+    +---+---+----+    +---+---+----+
|   | -> |   |   |    |
+---+    +---+---+----+    +---+---+----+
|   | -------------------> |   |   |    |
+---+                      +---+---+----+

现在为arrayOfStructs中的每个条目分配，因此如果
m
是元素数：

for (int i = 0; i < n; ++i)
{
  arrayOfStructs[i] = malloc(m * sizeof(Element));
}

“元素数组”1..3（或者更确切地说是0..2）中的每个元素指向不同的“数据”（以下元素数组上的元素旋转90度，以便我可以更轻松地绘制方框）：

如果需要元素*的数组，则可以执行如下操作，其中is
n
是指针的数量：

Element** arrayOfStructs = malloc( n* sizeof(Element*) ); 

n=4时也是如此；您将得到一个由4个指针组成的数组：

Element** arrayOfStructs = malloc( n* sizeof(Element*) ); 

阵列结构

+---+
|   | ->
+---+
|   | ->
+---+
|   | ->
+---+
|   | ->
+---+

+---+    +---+---+----+
|   | -> |   |   |    |  array of Elements
+---+    +---+---+----+    +---+---+----+
|   | -------------------> |   |   |    |
+---+    +---+---+----+    +---+---+----+
|   | -> |   |   |    |
+---+    +---+---+----+    +---+---+----+
|   | -------------------> |   |   |    |
+---+                      +---+---+----+

现在为arrayOfStructs中的每个条目分配，因此如果
m
是元素数：

for (int i = 0; i < n; ++i)
{
  arrayOfStructs[i] = malloc(m * sizeof(Element));
}

“元素数组”1..3（或者更确切地说是0..2）中的每个元素指向不同的“数据”（以下元素数组上的元素旋转90度，以便我可以更轻松地绘制方框）：

我想你不想那样。如果你能使用
struct
s，那么你所考虑的数据结构就不是很好。你可以把你的“数组”写成一个结构，并拥有一个数组。我不能百分之百确定我是否理解你的意思，所以数组数组在我的e