C语言 如何为任意长度的结构数组分配内存并指向它

Question

struct foo{
member
member
}array[]
struct bar{
member
member
struct foo* p
}
array = malloc(10 * sizeof(struct foo))
p = &array[0]

我想为结构 foo 数组应容纳的任意数字重新分配内存。我该怎么做？我还希望 struct foo* p 指向结构 foo 数组。我做错了什么，但我不知道如何思考这个问题。

如果我不能以这种方式重新分配结构数组，那我该怎么办？

Answer 1

如果我理解你，你想创建一个包含 foo 类型元素的数组。 以下代码执行此操作：

    (001)    int   number = 10, ndx;
    (002)
    (003)    typedef struct _foo
    (004)    {
    (005)        int member1;
    (006)        int member2;
    (007)    } foo, *pfoo;
    (008)
    (009)    pfoo ptr = malloc(number * sizeof(foo));

那么这是怎么回事。 flines 3 到 7 定义了您的新类型（结构，我刚刚包含两个整数以使其具体化）。 此外，typedef（记住typedef的语法是typedef old_type_name type_alias）部分为你的结构添加了两个别名。

 foo is equivalent to struct _foo 
 pfoo is equivalent to struct _foo*

第 9 行现在在堆上分配一个内存块，该内存块足够大，可以容纳 number 个struct _foo (or foo for short)副本。

那么，您将如何在代码中使用它。 以下一段代码将数组索引存储在第一个成员中，将索引的平方存储在第二个成员中。

   (010)    for(ndx = 0; ndx < number; ndx++)
   (011)    {
   (012)         ptr[ndx].member1 = ndx;
   (013)         ptr[ndx].member2 = ndx*ndx;
   (014)    }

所以，

这可能有点深奥，所以这里是重要的要记住的要点;

1. PTR 是一个指向内存块的指针，该内存块足够大，可以容纳 Foo 类型的number元素。
2. 数组索引表示法，即 ptr[]，实际上是指针算术的语法糖。 例如ptr[3]等效于 ptr + 3*sizeof(foo) 。 换句话说，我们能够在第 1 点中创建的大内存中从一个子块移动到另一个子块。
3. 第 2 点中的算术产生一个匿名临时变量，该变量引用特定的子块（我们知道它是一个结构）。因为我们告诉编译器每个块都是一个结构，所以我们能够使用成员引用 （.） 来获取单个字段。

因此，将所有这些放在一个简短的程序中会产生：

    #include <stdio.h>
    #include <stdlib.h>
    typedef struct _foo
    {
        int member1;
        int member2;
    } foo, *pfoo;
    int main(int argc, char** argv)
    {
        int   number = 10, ndx;
        pfoo ptr = malloc(number * sizeof(foo));
        for(ndx = 0; ndx < number; ndx++)
        {
            ptr[ndx].member1 = ndx;
            ptr[ndx].member2 = ndx*ndx;
        }
        for(ndx = 0; ndx < number; ndx++)
        {
            foo     temp = ptr[ndx];
            printf("%dt%dn", temp.member1, temp.member2);
        }
        return 0;
    }

在我的系统（Ubuntu Linux）上，这使用命令行干净地编译： gcc -ansi -Wall -pedanic temp.c -o temp

---

[编辑] - 忘记回答问题的第二部分。

综上所述，您的第二个问题的答案现在应该相当明显（我希望）。

好的，所以你现在要使用的两个结构是：

    typedef struct _foo
    {
        int member1;
        int member2;
    } foo, *pfoo;
    typedef struct _bar
    {
        int  member1;
        int  member2;
        pfoo p;     /* or alternatively, struct _foo* p    */
                    /* or alternatively, foo* p            */
    } bar, *pbar;

此时，您可以在代码中编写：

    bar      temp;
    temp.member1 = 5;
    temp.member2 = 10;
    temp.p = malloc(number*sizeof(foo));

希望这有帮助，T.

Answer 2

这是一个你想要实现的目标的运行示例 - 你可以在ideone上使用它。

#include <stdio.h>
#include <stdlib.h>
typedef struct {
 int haz;
 int cheez;
} foo;
typedef struct {
 foo* p;
} bar;
int main(void) {
    // your code goes here
    bar mybar;
    bar *mybar_ptr;
    foo* myfoo_array  = malloc(10*sizeof *myfoo_array);
    if(myfoo_array == NULL) {
      puts("ERROR: Could not allocate memory");
      return 1;
    }       
    myfoo_array[5].haz   = 1337;
    myfoo_array[5].cheez = 42;
    mybar.p   = myfoo_array;
    //  assigns the address of mybar to the mybar_ptr 
    mybar_ptr = &mybar;
    printf("haz: %d, cheez: %dn", mybar.p[5].haz, mybar.p[5].cheez);
    // access as pointer
    printf("haz: %d, cheez: %dn", mybar_ptr->p[5].haz, mybar_ptr->p[5].cheez);
    return 0;
}