我一直在回到 C 语言中，但是我很难记住这种内存管理的大部分工作原理。我想要一个指向结构指针数组的指针。
说我有：
struct Test {
int data;
};
然后是数组：
struct Test **array1;
它是否正确？我的问题是处理这件事。所以数组中的每个指针都指向单独分配的东西。但我认为我需要先这样做：
array1 = malloc(MAX * sizeof(struct Test *));
我无法理解上述内容。我需要这样做吗，为什么需要这样做？特别是，如果我要为指针指向的每个事物分配内存，那么为指针分配内存意味着什么？
现在说我有一个指向结构指针数组的指针。我现在希望它指向我之前创建的同一个数组。
struct Test **array2;
我是否需要像上面那样为指针分配空间，或者我可以这样做：
array2 = array1
分配的数组
使用分配的数组很容易理解。
声明你的指针数组。此数组中的每个元素都指向一个struct Test：
struct Test *array[50];
然后根据需要分配和分配指向结构的指针。使用循环很简单：
array[n] = malloc(sizeof(struct Test));
然后声明一个指向这个数组的指针：
// an explicit pointer to an array
struct Test *(*p)[] = &array; // of pointers to structs
这允许您使用(*p)[n]->data; 引用第 n 个成员。
如果这些东西令人困惑，请不要担心。这可能是 C 语言中最困难的方面。
动态线性阵列
如果您只想分配一个结构块（实际上是一个结构数组，而不是指向结构的指针），并且有一个指向该块的指针，您可以更轻松地做到这一点：
struct Test *p = malloc(100 * sizeof(struct Test)); // allocates 100 linear
// structs
然后你可以指向这个指针：
struct Test **pp = &p
您不再有指向结构的指针数组，但它大大简化了整个事情。
动态分配结构的动态数组
最灵活，但并不经常需要。它与第一个示例非常相似，但需要额外分配。我编写了一个完整的程序来演示这个应该可以正常编译。
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
struct Test {
int data;
};
int main(int argc, char **argv)
{
srand(time(NULL));
// allocate 100 pointers, effectively an array
struct Test **t_array = malloc(100 * sizeof(struct Test *));
// allocate 100 structs and have the array point to them
for (int i = 0; i < 100; i++) {
t_array[i] = malloc(sizeof(struct Test));
}
// lets fill each Test.data with a random number!
for (int i = 0; i < 100; i++) {
t_array[i]->data = rand() % 100;
}
// now define a pointer to the array
struct Test ***p = &t_array;
printf("p points to an array of pointers.\n"
"The third element of the array points to a structure,\n"
"and the data member of that structure is: %d\n", (*p)[2]->data);
return 0;
}
输出：
> p points to an array of pointers.
> The third element of the array points to a structure,
> and the data member of that structure is: 49
或整套：
for (int i = 0; i < 100; i++) {
if (i % 10 == 0)
printf("\n");
printf("%3d ", (*p)[i]->data);
}
35 66 40 24 32 27 39 64 65 26
32 30 72 84 85 95 14 25 11 40
30 16 47 21 80 57 25 34 47 19
56 82 38 96 6 22 76 97 87 93
75 19 24 47 55 9 43 69 86 6
61 17 23 8 38 55 65 16 90 12
87 46 46 25 42 4 48 70 53 35
64 29 6 40 76 13 1 71 82 88
78 44 57 53 4 47 8 70 63 98
34 51 44 33 28 39 37 76 9 91
单动态分配结构的动态指针数组
最后一个例子是相当具体的。正如我们在前面的示例中看到的，它是一个动态的指针数组，但与这些不同的是，元素都在一次分配中分配。这有其用途，最值得注意的是在不同配置中对数据进行排序，同时保持原始分配不受干扰。
我们首先分配一个元素块，就像我们在最基本的单块分配中所做的那样：
struct Test *arr = malloc(N*sizeof(*arr));
现在我们分配一个单独的指针块：
struct Test **ptrs = malloc(N*sizeof(*ptrs));
然后，我们用原始数组之一的地址填充指针列表中的每个槽。由于指针算法允许我们从一个元素移动到另一个元素地址，这很简单：
for (int i=0;i<N;++i)
ptrs[i] = arr+i;
此时以下都指的是同一个元素字段
arr[1].data = 1;
ptrs[1]->data = 1;
经过以上审查，我希望清楚原因。
当我们完成指针数组和原始块数组时，它们被释放为：
free(ptrs);
free(arr);
注意：我们不会单独释放ptrs[]数组中的每个项目。这不是他们的分配方式。它们被分配为单个块（由 指向arr），这就是它们应该被释放的方式。
那么为什么有人要这样做呢？几个原因。
首先，它从根本上减少了内存分配调用的数量。而不是N+1（一个用于指针数组，N 用于单个结构）您现在只有两个：一个用于数组块，一个用于指针数组。内存分配是程序可以请求的最昂贵的操作之一，并且在可能的情况下，最好将它们最小化（注意：文件 IO 是另一个，仅供参考）。
另一个原因：同一基本数据数组的多种表示形式。假设您想对数据进行升序和降序排序，并同时提供两种排序表示。您可以复制数据数组，但这需要大量复制并占用大量内存。相反，只需分配一个额外的指针数组并用基数组中的地址填充它，然后对该指针数组进行排序。当被排序的数据很大（每个项目可能是千字节，甚至更大）时，这具有特别显着的好处。原始项目保留在基本数组中的原始位置，但是现在您有了一个非常有效的机制，您可以在其中对它们进行排序无需实际移动他们。您对指向项目的指针数组进行排序；这些物品根本不会移动。
我意识到这是一个非常重要的内容，但是指针的使用对于理解 C 语言可以做的许多强大的事情至关重要，所以请阅读书籍并不断刷新你的记忆。它会回来的。
正如其他人所建议的那样，声明一个实际的数组可能会更好，但您的问题似乎更多的是关于内存管理，所以我将讨论这个问题。
struct Test **array1;
这是指向 a 地址的指针struct Test。（不是指向结构本身的指针；它是指向保存结构地址的内存位置的指针。）声明为指针分配内存，但不为其指向的项目分配内存。由于可以通过指针访问数组，因此您可以将其*array1用作指向元素类型为 的数组的指针struct Test。但是还没有一个实际的数组可以指向它。
array1 = malloc(MAX * sizeof(struct Test *));
这会分配内存来保存MAX指向类型项目的指针struct Test。同样，它不会为结构本身分配内存；仅用于指针列表。但是现在您可以将array其视为指向已分配指针数组的指针。
为了使用array1，您需要创建实际的结构。您可以通过简单地声明每个结构来做到这一点
struct Test testStruct0; // Declare a struct.
struct Test testStruct1;
array1[0] = &testStruct0; // Point to the struct.
array1[1] = &testStruct1;
您还可以在堆上分配结构：
for (int i=0; i<MAX; ++i) {
array1[i] = malloc(sizeof(struct Test));
}
分配内存后，您可以创建一个指向相同结构列表的新变量：
struct Test **array2 = array1;
您不需要分配任何额外array2的内存，因为指向您分配给array1.
有时您想要一个指向指针列表的指针，但除非您正在做一些花哨的事情，否则您可以使用
struct Test *array1 = malloc(MAX * sizeof(struct Test)); // Pointer to MAX structs
这声明了指针array1，为结构分配了足够的内存MAX，并指向array1该内存。现在您可以像这样访问结构：
struct Test testStruct0 = array1[0]; // Copies the 0th struct.
struct Test testStruct0a= *array1; // Copies the 0th struct, as above.
struct Test *ptrStruct0 = array1; // Points to the 0th struct.
struct Test testStruct1 = array1[1]; // Copies the 1st struct.
struct Test testStruct1a= *(array1 + 1); // Copies the 1st struct, as above.
struct Test *ptrStruct1 = array1 + 1; // Points to the 1st struct.
struct Test *ptrStruct1 = &array1[1]; // Points to the 1st struct, as above.
那么有什么区别呢？一些东西。显然，第一种方法要求您为指针分配内存，然后为结构本身分配额外的空间；第二个让你一malloc()通电话就可以逃脱。额外的工作能给你带来什么？
由于第一种方法为您提供了一个指向Test结构的实际指针数组，因此每个指针都可以指向Test内存中任何位置的任何结构；它们不必是连续的。此外，您可以根据需要为每个实际Test结构分配和释放内存，并且可以重新分配指针。因此，例如，您可以通过简单地交换它们的指针来交换两个结构：
struct Test *tmp = array1[2]; // Save the pointer to one struct.
array1[2] = array1[5]; // Aim the pointer at a different struct.
array1[5] = tmp; // Aim the other pointer at the original struct.
另一方面，第二种方法为所有Test结构分配一个连续的内存块，并将其划分为MAX项目。并且数组中的每个元素都驻留在固定位置；交换两个结构的唯一方法是复制它们。
指针是 C 语言中最有用的结构之一，但它们也可能是最难理解的结构之一。如果您打算继续使用 C，那么花一些时间使用指针、数组和调试器，直到您对它们感到满意为止，这可能是一项值得的投资。
祝你好运！
我建议您使用 typdefs 一次构建一个层来创建类型层。通过这样做，所需的不同类型将更加清晰。
例如：
typedef struct Test {
int data;
} TestType;
typedef TestType * PTestType;
这将创建两种新类型，一种用于结构，另一种用于指向结构的指针。
所以接下来如果你想要一个结构数组，那么你将使用：
TestType array[20]; // creates an array of 20 of the structs
如果你想要一个指向结构的指针数组，那么你可以使用：
PTestType array2[20]; // creates an array of 20 of pointers to the struct
然后，如果您想将结构分配到数组中，您可以执行以下操作：
PTestType array2[20]; // creates an array of 20 of pointers to the struct
// allocate memory for the structs and put their addresses into the array of pointers.
for (int i = 0; i < 20; i++) {
array2 [i] = malloc (sizeof(TestType));
}
C 不允许您将一个数组分配给另一个数组。您必须改为使用循环将一个数组的每个元素分配给另一个数组的元素。
编辑：另一种有趣的方法
另一种方法是更面向对象的方法，您可以在其中封装一些东西。例如，使用相同的类型层，我们创建了两种类型：
typedef struct _TestData {
struct {
int myData; // one or more data elements for each element of the pBlob array
} *pBlob;
int nStructs; // count of number of elements in the pBlob array
} TestData;
typedef TestData *PTestData;
接下来我们有一个帮助函数，我们用它来创建对象，命名得当CreateTestData (int nArrayCount)。
PTestData CreateTestData (int nCount)
{
PTestData ret;
// allocate the memory for the object. we allocate in a single piece of memory
// the management area as well as the array itself. We get the sizeof () the
// struct that is referenced through the pBlob member of TestData and multiply
// the size of the struct by the number of array elements we want to have.
ret = malloc (sizeof(TestData) + sizeof(*(ret->pBlob)) * nCount);
if (ret) { // make sure the malloc () worked.
// the actual array will begin after the end of the TestData struct
ret->pBlob = (void *)(ret + 1); // set the beginning of the array
ret->nStructs = nCount; // set the number of array elements
}
return ret;
}
现在我们可以在下面的源代码段中使用我们的新对象。它应该检查从 CreateTestData() 返回的指针是否有效，但这实际上只是为了说明可以做什么。
PTestData go = CreateTestData (20);
{
int i = 0;
for (i = 0; i < go->nStructs; i++) {
go->pBlob[i].myData = i;
}
}
在真正动态的环境中，您可能还希望拥有一个ReallocTestData(PTestData p)重新分配TestData对象的函数，以修改对象中包含的数组的大小。
使用这种方法，当您完成特定的 TestData 对象时，您可以像 in 一样释放该对象，free (go)并且同时释放该对象及其数组。
编辑：进一步扩展
有了这个封装的类型，我们现在可以做一些其他有趣的事情。例如，我们可以有一个复制函数，PTestType CreateCopyTestData (PTestType pSrc)它会创建一个新实例，然后将参数复制到一个新对象。在下面的示例中，我们重用PTestType CreateTestData (int nCount)将创建我们类型实例的函数，使用我们正在复制的对象的大小。在创建新对象之后，我们从源对象复制数据。最后一步是修复源对象中指向其数据区的指针，使新对象中的指针现在指向自身的数据区，而不是旧对象的数据区。
PTestType CreateCopyTestData (PTestType pSrc)
{
PTestType pReturn = 0;
if (pSrc) {
pReturn = CreateTestData (pSrc->nStructs);
if (pReturn) {
memcpy (pReturn, pSrc, sizeof(pTestType) + pSrc->nStructs * sizeof(*(pSrc->pBlob)));
pReturn->pBlob = (void *)(pReturn + 1); // set the beginning of the array
}
}
return pReturn;
}
结构与其他对象没有太大区别。让我们从字符开始：
char *p;
p = malloc (CNT * sizeof *p);
*p 是一个字符，所以sizeof *psizeof (char) == 1; 我们分配了 CNT 字符。下一个：
char **pp;
pp = malloc (CNT * sizeof *pp);
*p is a pointer to character, so sizeof *pp is sizeof (char*). We allocated CNT pointers. Next:
struct something *p;
p = malloc (CNT * sizeof *p);
*p is a struct something, so sizeof *p is sizeof (struct something). We allocated CNT struct somethings. Next:
struct something **pp;
pp = malloc (CNT * sizeof *pp);
*pp is a pointer to struct, so sizeof *pp is sizeof (struct something*). We allocated CNT pointers.