是否可以使结构数组的地址等于指向 malloc 内存的指针？答案

【问题标题】：Is it possible to make the address of a struct-array equal to a pointer to malloc'd memory?是否可以使结构数组的地址等于指向 malloc 内存的指针？
【发布时间】：2017-03-10 11:44:34
【问题描述】：

在我最初创建 trie 的方法中，我尝试在 malloc 内存中放置一个结构数组，而不是使用指向左/右的指针。这可能吗？原则上可以struct array[] = struct* head吗？

好的，这是我使用的代码：

typedef struct node
{
    char letter;
    struct node* child;
}
node;

int main(void)
{
    node* head = malloc(26*sizeof(node));
    if (head == NULL)
        return 1;

    node* temp = head;

    node array[26];

    array = temp;
    //proceed to fill array...

我不明白的是，如果指针和array[]都是内存中的地址，为什么不能等同？

【问题讨论】：

不，你不能。试试看 (demo): "error: incompatible types when assignment to type ‘int[10]' from type ‘int *’”。从根本上说，指针不是数组，数组也不是指针。在某些情况下，数组只是衰减为指针。但两者是截然不同的类型。即使这是可能的，它也会导致无数的问题/UB：arr = ptr; free(ptr); printf("%d\n", arr[0]); == 繁荣。类似的东西
不可以，但是你可以把head指针当成数组使用，head[0].some_member、head[1].some_other_member等等
您能用代码说明您要做什么吗？
您是创建 trie（每个节点 26 个子节点）还是 binary tree（每个节点 2 个子节点）？跨度>
好的，谢谢@user3386109。我想我现在明白了。

标签： c arrays pointers struct trie

【解决方案1】：

如你所知，指针并不完全是一种数据类型，即容量（或使用的字节数），而只是一个内存方向引用：一个数字（表示为 XXXXX:XXXXX 主要情况和在main SO 作为 4 字节数字）表示内存页和该页内的偏移量。该方向引用的内存可能已分配，也可能未分配。就是这样，标记为 SO 保留供您的程序使用。但在任何情况下，它只针对该变量受到保护：您的程序可以使用该内存块，例如，将其分配给任何类型的变量。如果为结构分配正确大小的内存，然后引用该内存地址，则可以毫无区别地使用它，就好像您已被声明为普通变量一样。

在本例中，您可以毫无区别地使用 ST S[3] 或 ST *S = malloc(sizeof(ST)*3);如所见， sizeof(ST) 将为您提供 4(int) + 1(char B) + 20*1(char[20]) = 25 个字节，而padding, 28. malloc(sizeof(ST)* 3）然后将为您的程序保留 84 个字节（当然更多，肯定是 128 个字节保留整个页面块），并将给您保留第一个字节的内存方向。其实这个 malloc 和声明 ST S[3] 差不多。

由于指针允许的大量可能性，因为直接访问内存（例如，大量变量共享相同的内存，或沿内存块上下移动的容量）它们因此难以管理，并且所以，一大堆错误，更喜欢更高级的抽象。但你的问题的答案是肯定的，有可能。

#include <malloc.h>

typedef struct ST
{
    int A;
    char B; 
    char C[20];
} ST;

int main(int agrc, char *agrv[])
{
    //  ST S[3];    
    ST *S = malloc(sizeof(ST)*3);
    //  ST *S = malloc(100);

    S[0].A = 1;         S[0].B = '1';       S[0].C[0] = 'a';
    S[0].C[1] = 'b';    S[0].C[2] = 'c';    S[0].C[3] = '\0';

    S[1].A = 2;         S[1].B = '2';       S[1].C[0] = 'A';
    S[1].C[1] = 'B';    S[1].C[2] = 'C';    S[1].C[3] = '\0';

    S[2].A = 3;         S[2].B = '3';       S[2].C[0] = 'Z';
    S[2].C[1] = 'z';    S[2].C[2] = 'Z';    S[2].C[3] = '\0';

    int i=0;
    for (i=0;i<3;i++)
    {
        printf("Struct %d\n",i);
        printf("%d\n",S[i].A);
        printf("%c\n",S[i].B);
        printf("%s\n",&S[i].C);
        printf("\n");
    }   
}

添加：这是相同的，但从另一种方式：转到内存中字符串的方向，并将其解释为我们的结构。

#include <malloc.h>

typedef struct ST
{
    short  A; // 2
    char B;  // 1
    char C[20]; // 20
} ST;

int main(int agrc, char *agrv[])
{
    char *s =malloc(28);

    s[0] = 65; // Lower byte of int
    s[1] = 65; // Higher byte of int
    s[2] = 'C'; 
    s[3] = 'a';
    s[4] = 'b';
    s[5] = 'c';
    s[6] = 0x00;

    printf("%s\n",s);

    ST *T;

    T = (void *)s;

    printf("%d\n",T[0].A);
    printf("%c\n",T[0].B);
    printf("%s\n",T[0].C);
}

【讨论】：