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

Question

struct foo{
member
member
}array[]

struct bar{
member
member
struct foo* p
}

array = malloc(10 * sizeof(struct foo))
p = &array[0]

我想为struct foo数组应保存的任意数字分配内存。 我怎么做？ 我还希望struct foo * p指向struct foo数组。 我对此做错了，但我不知道如何思考。

如果我无法以这种方式分配结构数组，那该怎么办呢？

Answer 1

这是您要实现的目标的运行示例-您可以在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: %d\n", mybar.p[5].haz, mybar.p[5].cheez);

    // access as pointer
    printf("haz: %d, cheez: %d\n", mybar_ptr->p[5].haz, mybar_ptr->p[5].cheez);

    return 0;
}

Answer 2

据我了解，您想创建一个包含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));

所以这是怎么回事。 3到7行代码定义了您的新类型（结构，我只添加了两个整数以使其具体化）。 另外，typedef（记住typedef的语法是typedef old_type_name type_alias ）部分为您的结构添加了两个别名。

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

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

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

   (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("%d\t%d\n", temp.member1, temp.member2);
        }

        return 0;
    }

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

---

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

有了以上所述，第二个问题的答案现在应该已经很明显了（我希望）。

好的，现在您要使用的两个结构是：

    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。