將靈活數組成員分配為結構

Question

我對指針和東西了解得更多，但是我不知道我在做什么錯。 如果我有char *（* data）[]那將被解釋為“指向char指針數組的指針”，對嗎？ 然后我有一個像這樣的結構，類型定義為myStruct，可能是多余的，但這是重點：

    typedef struct myStruct myStruct;
    struct myStruct{
      int size;
      char *name;
      myStruct *(*array)[];
}

在網站上尋找類似的帖子后，我得到了如下信息：

    //let's say allocating 5 spaces for this case
    myStruct *a = malloc(sizeof(myStruct)+ sizeof(struct myStruct *)*5);

我確定分配給我的結構體的數量是數組的大小。 我對此不太了解，如果是結構，它如何工作？ 這里的計划是擁有這個結構，它包含5個myStruct的數組。 我也必須分別分配它們嗎？ 像這樣？

    a->array[0] = malloc( .... ) 

我嘗試了一下，它一直給我一個錯誤，提示未有效使用帶有未指定范圍的數組。 我做錯了什么或該如何解決？ 謝謝

Answer 1

myStruct *(*array)[]; 不是靈活的數組成員，因為它不是數組類型。 它是恰好指向不完整數組類型的指針 。

靈活數組成員的一般模式是：

struct myStruct {
    int size;
    char *name;
    Type array[];
};

在您的情況下，Type將由typedef MyStruct * Type;定義typedef MyStruct * Type; 。 我假設您想要一個包含5個指針的數組。 （當然，這與在結構中具有myStruct *array[];效果相同）。

（如果您確實希望結構包含一個指向5個元素的數組的指針，那么使用靈活的數組成員不是正確的方法）。

您的malloc對於我剛才給出的定義是正確的。 它分配了一個連續的內存塊，您可以像實際上是由5個對象組成的array那樣使用array ，但不能對它進行sizeof查找大小。

Answer 2

從您的評論看來，您似乎想要一個指向結構的指針數組的指針，而不是指向結構的數組的指針，因為“指向char *數組的指針”也具有兩個間接級別。

區別在於：

1. 指向結構的指針：

2. 指向結構數組的指針：

3. 指向結構指針數組的指針：

假設您想要＃3，則可以這樣做（在“傳統” C語言中）：

typedef struct myStruct myStruct;

struct myStruct
{
    int        size;
    char      *name;
    myStruct **array;
};

myStruct *allocate_node(char *name, int size)
{
    myStruct *p_node;
    if (size < 0)
        size = 0;
    p_node = calloc(1, sizeof(myStruct));
    p_node->name = name;
    p_node->size = size;
    p_node->array = calloc(1, size * sizeof(myStruct *));

    return p_node;
}

void expand_node_child_array(myStruct *p_node, int size_to_add)
{
    if (size_to_add < 1 || p_node == NULL)
        return;
    if (p_node->array == NULL)
    {
        p_node->size = size_to_add;
        p_node->array = calloc(1, size_to_add * sizeof(myStruct *));
    }
    else
    {
        p_node->array = realloc(p_node->array, (p_node->size + size_to_add) * sizeof(myStruct *));
        memset(p_node->array + p_node->size * sizeof(myStruct *), 0, size_to_add * sizeof(myStruct *));
        p_node->size += size_to_add;
    }
}

myStruct *get_child_node(myStruct *p_node, int index)
{
    if (index < 0 || index >= p_node->size)
        return 0;
    return p_node->array[index];
}

int set_child_node(myStruct *p_node, int index, myStruct *p_child)
{
    if (index < 0 || index >= p_node->size)
        return FALSE;
    p_node->array[index] = p_child;
    return TRUE;
}

void free_node(myStruct **pp_node)
{
    // Free p_node and the array but DO NOT free the children
    if (pp_node == NULL || *pp_node == NULL)
        return;
    if ((*pp_node)->array != NULL)
        free((*pp_node)->array);
    free((*pp_node));
    *pp_node = NULL;
}

void free_node_and_children(myStruct **pp_node)
{
    int iChild;

    if (pp_node == NULL || *pp_node == NULL)
        return;
    for (iChild = 0; iChild < (*pp_node)->size; iChild++)
    {
        myStruct *p_child = get_child_node((*pp_node), iChild);
        if (p_child != NULL)
            free_node_and_children(&p_child);
        set_child_node((*pp_node), iChild, NULL);
    }
    free_node(pp_node);
}

更新資料

根據C99標准語法，靈活數組是一個可變長度數組，它出現在結構的尾部，其實際長度在運行時設置。 在內存中看起來像這樣：

假設您的編譯器支持這種語法（並非全部），則可以這樣聲明：

struct myStruct
{
    Type  array_of_type[]; /* AT THE END OF THE STRUCT ONLY */
};

並且“ myStruct”的代碼變為：

typedef struct myStruct myStruct;

struct myStruct
{
    int        size;
    char      *name;
    myStruct  *array[];
};

myStruct *allocate_node(char *name, int size)
{
    myStruct *p_node;
    if (size < 0)
        size = 0;
    p_node = calloc(1, sizeof(myStruct) + size * sizeof(myStruct *));
    p_node->name = name;
    p_node->size = size;

    return p_node;
}

myStruct *get_child_node(myStruct *p_node, int index)
{
    if (index < 0 || index >= p_node->size)
        return NULL;
    return p_node->array[index];
}

int set_child_node(myStruct *p_node, int index, myStruct *p_child)
{
    if (index < 0 || index >= p_node->size)
        return FALSE;
    p_node->array[index] = p_child;
    return TRUE;
}

void free_node(myStruct **pp_node)
{
    if (pp_node == NULL || *pp_node == NULL)
        return;
    free((*pp_node));
    *pp_node = NULL;
}

void free_node_and_children(myStruct **pp_node)
{
    int iChild;

    if (pp_node == NULL || *pp_node == NULL)
        return;
    for (iChild = 0; iChild < (*pp_node)->size; iChild++)
    {
        myStruct *p_child = get_child_node((*pp_node), iChild);
        if (p_child != NULL)
            free_node_and_children(&p_child);
        set_child_node((*pp_node), iChild, NULL);
    }
    free_node(pp_node);
}

如果您沒有編譯器，請參見此處了解一些解決方法。

使用靈活的數組，擴展數組將需要重新分配節點本身並固定對它的所有引用，這在“指針數組的指針”設計中是不需要的。

您使用的語法：

    myStruct  *(*array)[];

應該理解為 “指向結構指針未知大小的數組的指針”，而不是

    myStruct  **array;

這是“指向結構的指針”，或：

    myStruct *(*array)[4];

這是“指向長度為4的指針的數組的指針。

您的語法實際上產生了內存映射3，但是訪問單個元素有點麻煩，因為您必須顯式地獲取“未知大小的數組”的第零個元素的指針，即(*p_node->array) 。 因此，對＃3中的函數進行了如下修改：

void expand_node_child_array(myStruct *p_node, int size_to_add)
{
    if (size_to_add < 1 || p_node == NULL)
        return;
    if (p_node->array == NULL)
    {
        p_node->size = size_to_add;
        p_node->array = calloc(1, size_to_add * sizeof(myStruct *));
    }
    else
    {
        p_node->array = realloc(p_node->array, (p_node->size + size_to_add) * sizeof(myStruct *));
        memset((*p_node->array) + p_node->size * sizeof(myStruct *), 0, size_to_add * sizeof(myStruct *));
        p_node->size += size_to_add;
    }
}

myStruct *get_child_node(myStruct *p_node, int index)
{
    if (index < 0 || index >= p_node->size)
        return NULL;
    return (*p_node->array)[index];
}

int set_child_node(myStruct *p_node, int index, myStruct *p_child)
{
    if (index < 0 || index >= p_node->size)
        return FALSE;
    (*p_node->array)[index] = p_child;
    return TRUE;
}

最后，兩種架構的測試代碼：

void dump_nodes_recursive(myStruct *p_node, int level)
{
    if (p_node == NULL)
    {
        printf("%*s", 4*level, " ");
        printf("NULL\n");
    }
    else
    {
        int iChild;
        printf("%*s", 4*level, " ");
        printf("Node: Name=\"%s\", array size=%d\n", p_node->name, p_node->size);
        for (iChild = 0; iChild < p_node->size; iChild++)
        {
            myStruct *p_child = get_child_node(p_node, iChild);
            printf("%*s", 4*level, " ");
            printf("Child [%d]:\n", iChild);
            dump_nodes_recursive(p_child, level+1);
        }
    }
}

void dump_nodes(myStruct *p_node)
{
    dump_nodes_recursive(p_node, 0);
}

void test_my_struct()
{
    myStruct *p_top = allocate_node("top", 4);
    myStruct *p_child0 = allocate_node("child0", 1);
    myStruct *p_child1 = allocate_node("child1", 5);
    myStruct *p_child2 = allocate_node("child2", 0);
    myStruct *p_child3 = allocate_node("child3", 0);
    myStruct *p_child00 = allocate_node("child00", 0);

    set_child_node(p_top, 0, p_child0);
    set_child_node(p_top, 1, p_child1);
    set_child_node(p_top, 2, p_child2);

    set_child_node(p_top, 3, p_child3);

    set_child_node(p_child0, 0, p_child00);

    dump_nodes(p_top);

    free_node_and_children(&p_top);
}