c - 实现动态结构数组的问题

Question

我在创建动态结构数组时遇到问题。我在这里和其他网站上看到并尝试实现了一些示例，这些示例以及它们分配内存的方式往往有所不同，而且我似乎无法让它们中的任何一个为我工作。任何帮助将不胜感激。

typedef struct node {
    int index;
    int xmin, xmax, ymin, ymax;
} partition;

partition* part1 = (partition *)malloc(sizeof(partition) * 50);

我什至都搞不清楚。它给了我以下错误:错误:初始化元素不是常量

如果有人能解释如何实现这样的事情，我将不胜感激。

此外，一旦我完成了该部分，我将如何将值添加到结构的元素中？像下面这样的东西可以工作吗？

part1[i]->index = x;

Answer 1

编译器提示是因为你正在做:

partition* part1 = (partition *)malloc(sizeof(partition) * 50);

这样做:

partition* part1;

int
main(void)
{

    part1 = (partition *)malloc(sizeof(partition) * 50);

    ...
}

您的版本在全局上使用了初始化程序，在 C 中它必须是常量值。通过将 malloc 移至函数中，您可以使用代码“初始化值”，但您没有使用语言中定义的初始化程序。

同样，您也可以有一个已初始化的全局变量:

int twenty_two = 22;

这里22是一个常量，因此是允许的。

更新:这是一个有点冗长的示例，将显示大多数可能的方法:

#define PARTMAX     50
partition static_partlist[PARTMAX];
partition *dynamic_partlist;

int grown_partmax;
partition *grown_partlist;

void
iterate_byindex_static_length(partition *partlist)
{
    int idx;

    for (idx = 0;  idx < PARTMAX;  ++idx)
        do_something(&partlist[idx]);
}

void
iterate_byptr_static_length(partition *partlist)
{
    partition *cur;
    partition *end;

    // these are all equivalent:
    //   end = partlist + PARTMAX;
    //   end = &partlist[PARTMAX];
    end = partlist + PARTMAX;

    for (cur = partlist;  cur < end;  ++cur)
        do_something(cur);
}

void
iterate_byindex_dynamic_length(partition *partlist,int partmax)
{
    int idx;

    for (idx = 0;  idx < partmax;  ++idx)
        do_something(&partlist[idx]);
}

void
iterate_byptr_dynamic_length(partition *partlist,int partmax)
{
    partition *cur;
    partition *end;

    // these are all equivalent:
    //   end = partlist + partmax;
    //   end = &partlist[partmax];
    end = partlist + partmax;

    for (cur = partlist;  cur < end;  ++cur)
        do_something(cur);
}

int
main(void)
{
    partition *part;

    dynamic_partlist = malloc(sizeof(partition) * PARTMAX);

    // these are all the same
    iterate_byindex_static_length(dynamic_partlist);
    iterate_byindex_static_length(dynamic_partlist + 0);
    iterate_byindex_static_length(&dynamic_partlist[0]);

    // as are these
    iterate_byptr_static_length(static_partlist);
    iterate_byptr_static_length(static_partlist + 0);
    iterate_byptr_static_length(&static_partlist[0]);

    // still the same ...
    iterate_byindex_dynamic_length(dynamic_partlist,PARTMAX);
    iterate_byindex_dynamic_length(dynamic_partlist + 0,PARTMAX);
    iterate_byindex_dynamic_length(&dynamic_partlist[0],PARTMAX);

    // yet again the same ...
    iterate_byptr_dynamic_length(static_partlist,PARTMAX);
    iterate_byptr_dynamic_length(static_partlist + 0,PARTMAX);
    iterate_byptr_dynamic_length(&static_partlist[0],PARTMAX);

    // let's grow an array dynamically and fill it ...
    for (idx = 0;  idx < 10;  ++idx) {
        // grow the list -- Note that realloc is smart enough to handle
        // the fact that grown_partlist is NULL on the first time through
        ++grown_partmax;
        grown_partlist = realloc(grown_partlist,
            grown_partmax * sizeof(partition));

        part = &grown_partlist[grown_partmax - 1];

        // fill in part with whatever data ...
    }

    // once again, still the same
    iterate_byindex_dynamic_length(grown_partlist,grown_partmax);
    iterate_byindex_dynamic_length(grown_partlist + 0,grown_partmax);
    iterate_byindex_dynamic_length(&grown_partlist[0],grown_partmax);

    // sheesh, do things ever change? :-)
    iterate_byptr_dynamic_length(grown_partlist,grown_partmax);
    iterate_byptr_dynamic_length(grown_partlist + 0,grown_partmax);
    iterate_byptr_dynamic_length(&grown_partlist[0],grown_partmax);
}

有两种基本方法可以对数组进行交互:通过索引和通过指针。如何定义数组并不重要(例如，global/static --> int myary[37]; 或通过 malloc/realloc --> int *myptr = malloc(sizeof(int) * 37);)。 “按索引”语法和“按指针”语法是可以互换的。如果您想要第 12 个元素，则以下内容都是等效的:

myary[12]
*(myary + 12)
*(&myary[12])

myptr[12]
*(myptr + 12)
*(&myptr[12])

这就是为什么上述所有方法都会产生相同的结果。