Question

struct foo{
member
member
}array[]

struct bar{
member
member
struct foo* p
}

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

我想为struct foo数组应该保存的任意数字mallocate内存。我怎么做？我也希望struct foo * p指向struct foo数组。我做错了什么，但我不知道怎么想这个。

如果我不能以这种方式对结构数组进行mallocate，那么我应该怎么做呢？

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));

那么这里发生了什么。 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)    }

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

ptr是一个指向内存块的指针，该内存块足以容纳foo类型的number个元素。
数组索引表示法，即。 ptr [] ，实际上是指针算术的语法糖。例如，ptr[3]相当于ptr + 3*sizeof(foo)。换句话说，我们能够在我们在第1点创建的大量内存中从子块移动到子块。
第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

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

有了上述内容，你的第二个问题的答案现在应该是相当明显的（我希望）。

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

    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));

希望这有帮助，吨。

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

2 个答案: