C语言中的结构数组

我将如何将此代码更改为一个包含25条记录的结构数组？ 我熟悉结构，但不确定如何声明和调用结构数组。任何帮助都将不胜感激

#include <stdio.h>

typedef struct household_t
{
    int  ID ;  
    int  Income ;  
    int  Members ; 
}  houset;

void  show_house ( houset ) ;

int main ( void) 
{
    houset  house = {1990 , 12180 , 5} ;
    show_house ( house );
    return 0 ;
}

void show_house ( houset  passed_house ) 
{
     printf ("\n\nID      Income  Members") ;
     printf ("\n\n%d      %d      %d \n\n\n", 
       passed_house.ID ,
       passed_house.Income ,
       passed_house.Members );
    return ;
}

---

可以将结构数组声明为

houset  house[25];  

并从主函数调用它作为

  show_house ( house[i] );

---

可以将结构数组声明为

houset  house[25];  

并从主函数调用它作为

  show_house ( house[i] );

---

它几乎和通常的C类型一样简单：

int main ( void) 
{
    houset houses[25];
    int i;
    for (i = 0; i < 25; i++) {
        houses[i].ID = 1990;
        houses[i].Income = 12180;
        houses[i].Members = 5;
        show_house (houses[i]);
    }
    return 0 ;
}

---

如果您初始化的结构少于25个，其他结构将被零填充。

这几乎和通常的C类型一样简单：

int main ( void) 
{
    houset houses[25];
    int i;
    for (i = 0; i < 25; i++) {
        houses[i].ID = 1990;
        houses[i].Income = 12180;
        houses[i].Members = 5;
        show_house (houses[i]);
    }
    return 0 ;
}

houset houses[25];

如果初始化少于25个结构，其他结构将用零填充

houset houses[25];

并将其用作函数参数：

void show_houses(houset * houses, int nHouses){

for(int i = 0; i < nHouses; i++){
show_house(houses[i]);
}

}

...

show_houses(houses, 25);

并将其用作函数参数：

void show_houses(houset * houses, int nHouses){

for(int i = 0; i < nHouses; i++){
show_house(houses[i]);
}

}

...

show_houses(houses, 25);

---

我想你的要求是这样的

household_t house_info[size*];

house_info[1] = {1990 , 12180 , 5};

---

我想你的要求是这样的

household_t house_info[size*];

house_info[1] = {1990 , 12180 , 5};

---

请看下面的代码。我希望这个概念简单易懂。 如果你遇到任何困难，发表评论

#include <stdio.h>

typedef struct household_t
{
    int  ID ;
    int  Income ;
    int  Members ;
}  houset;

void  show_house ( houset[],int ) ;

int main ( void)
{
    houset  house[2] = {{1990 , 12180 , 5},{1220,12211,3}} ;
    show_house ( house, 2); //size of array of struct
    return 0 ;
}

void show_house ( houset  passed_house[], int size )
{
int i=0;
 for (i=0;i<size;i++)
{
     printf ("\n\nID      Income  Members") ;
     printf ("\n\n%d      %d      %d \n\n\n",
       passed_house[i].ID ,
       passed_house[i].Income ,
       passed_house[i].Members );
}
    return ;
}

---

请看下面的代码。我希望这个概念简单易懂。 如果你遇到任何困难，发表评论

#include <stdio.h>

typedef struct household_t
{
    int  ID ;
    int  Income ;
    int  Members ;
}  houset;

void  show_house ( houset[],int ) ;

int main ( void)
{
    houset  house[2] = {{1990 , 12180 , 5},{1220,12211,3}} ;
    show_house ( house, 2); //size of array of struct
    return 0 ;
}

void show_house ( houset  passed_house[], int size )
{
int i=0;
 for (i=0;i<size;i++)
{
     printf ("\n\nID      Income  Members") ;
     printf ("\n\n%d      %d      %d \n\n\n",
       passed_house[i].ID ,
       passed_house[i].Income ,
       passed_house[i].Members );
}
    return ;
}

---

您要做的是创建一个数组，就像其他数组一样：

houset hose_array[25] = {
     {1990 , 12180 , 5},
     {1234 , 56789 , 0}
};//initialize here, if you want to

但是您必须更改show_house函数，因为在大多数情况下，当您将数组传递给函数时，数组会衰减为指针。也许可以改成这样：

void show_houses(houset *houses, int len)
{
    puts("\n\nID      Income  Members\n") ;
    while(len)
    {
        printf ("%d      %d      %d \n", 
               passed_house->ID ,//indirection operators!
               passed_house->Income ,
               passed_house->Members );
               passed_house++;//move pointer to next house
        --len;
    }
}

这将打印出len指定的所有房屋

堆栈溢出： 请注意，您可能会发现这样的数组可能会耗尽堆栈内存。在这种情况下，您将发现自己正在使用指向结构的指针数组或指向指针的指针。如果你不熟悉C语言中的动态内存，我建议你先读一下。。。 如果您知道它是如何工作的，或多或少：

houset *house[25];//an array of 25 pointers:
house[0] = malloc(sizeof(houset));
//we're dealing with a pointer, and need the indirection operator here, too
house[0]->ID = 1990;
//the alternative is less readable, IMO:
(*house[0]).Income = 12180;//deref pointer, then direct access is poissible
house[0]->Members = 5;
house[1] = malloc(sizeof(houset));
house[1]->ID = 1991;
house[1]->Income = 22180;
house[1]->Members = 3;

但现在，正如我所说的：数组会退化为指针，所以我们也必须再次更改show_house函数。这就是它变得有点棘手的地方：

void show_houses(houset **houses, int len)
{//pointer to pointer!
    puts("ID      Income  Members\n") ;
    while(len)
    {//dereference the first pointer
        printf ("%d      %d      %d \n", 
                (*passed_house)->ID ,//second pointer, still requires indirection 
                (*passed_house)->Income ,
                (*passed_house)->Members );
        passed_house++;//shift pointer to pointer by 1
        --len;
    }
}

完成后，不要忘记释放内存：

free(house[0]);
free(house[1]);

以避免mem泄漏。

---

同样，可以作为一个工作示例

您要做的是创建一个数组，就像其他任何数组一样：

houset hose_array[25] = {
     {1990 , 12180 , 5},
     {1234 , 56789 , 0}
};//initialize here, if you want to

但是您必须更改show_house函数，因为在大多数情况下，当您将数组传递给函数时，数组会衰减为指针。也许可以改成这样：

void show_houses(houset *houses, int len)
{
    puts("\n\nID      Income  Members\n") ;
    while(len)
    {
        printf ("%d      %d      %d \n", 
               passed_house->ID ,//indirection operators!
               passed_house->Income ,
               passed_house->Members );
               passed_house++;//move pointer to next house
        --len;
    }
}

这将打印出len指定的所有房屋

堆栈溢出： 请注意，您可能会发现这样的数组可能会耗尽堆栈内存。在这种情况下，您将发现自己正在使用指向结构的指针数组或指向指针的指针。如果你不熟悉C语言中的动态内存，我建议你先读一下。。。 如果您知道它是如何工作的，或多或少：

houset *house[25];//an array of 25 pointers:
house[0] = malloc(sizeof(houset));
//we're dealing with a pointer, and need the indirection operator here, too
house[0]->ID = 1990;
//the alternative is less readable, IMO:
(*house[0]).Income = 12180;//deref pointer, then direct access is poissible
house[0]->Members = 5;
house[1] = malloc(sizeof(houset));
house[1]->ID = 1991;
house[1]->Income = 22180;
house[1]->Members = 3;

但现在，正如我所说的：数组会退化为指针，所以我们也必须再次更改show_house函数。这就是它变得有点棘手的地方：

void show_houses(houset **houses, int len)
{//pointer to pointer!
    puts("ID      Income  Members\n") ;
    while(len)
    {//dereference the first pointer
        printf ("%d      %d      %d \n", 
                (*passed_house)->ID ,//second pointer, still requires indirection 
                (*passed_house)->Income ,
                (*passed_house)->Members );
        passed_house++;//shift pointer to pointer by 1
        --len;
    }
}

完成后，不要忘记释放内存：

free(house[0]);
free(house[1]);

以避免mem泄漏。

---

同样，可以作为一个工作示例

创建一个结构数组，并根据需要将其中的每一个或全部传递到show_house函数中

---

e、 g house something[number]，然后将其传递给show house函数

创建一个结构数组，并根据需要将其中的每一个或全部传递到show_house函数中

---

e、 g houst something[number]，然后将其传递给show house函数

就像任何其他数组一样：houst arrOf[10]；声明一个由10个house结构组成的数组…但是10应该是25，因为他需要25条记录：到OP:请注意，接受的答案可能会导致臭名昭著的问题，在此问题之后，此站点被命名为：。程序增长越多，就越有可能成为堆栈溢出。一定要通读我的答案，它解释了一种解决方法…谢谢你的信息，非常有用！就像其他阵列一样：House-arrOf[10]；声明一个由10个house结构组成的数组…但是10应该是25，因为他需要25条记录：到OP:请注意，接受的答案可能会导致臭名昭著的问题，在此问题之后，此站点被命名为：。程序增长越多，就越有可能成为堆栈溢出。一定要通读我的答案，它解释了一种解决方法…谢谢你的信息，非常有用！如果OP试图创建一个包含25个结构的数组时堆栈耗尽怎么办？他最终会得到一系列指针，这将大大改变show_house的功能…@EliasVanOotegem-这只是Nick完成工作的一种方式。虽然您的代码是有意义的，如果您考虑代码复杂度。但您的代码足够复杂，初学者无法理解。Thanks@vishram0709是的，你的代码帮了我很多，而且很容易理解！然而，埃利亚斯提出了一个很好的观点。@vishram0709：你被投了赞成票，但其他人投了反对票。我不知道你为什么会得到DV，但它与我对可能的堆栈的评论一致

---

我被投票支持。我的猜测是有人发现没有人提到堆栈耗尽的危险是你回答-1的理由。注：我没有否决投票。我只反对那些完全错误的答案，并且包含不好的、不实用的答案code@vishram0709当前位置我也投了赞成票，但其他人似乎投了你反对票，不知道为什么。你的回答很有帮助，也很容易理解。继续努力，感谢您的回复！如果OP试图创建一个包含25个结构的数组时堆栈耗尽怎么办？他最终会得到一系列指针，这将大大改变show_house的功能…@EliasVanOotegem-这只是Nick完成工作的一种方式。虽然您的代码是有意义的，如果您考虑代码复杂度。但您的代码足够复杂，初学者无法理解。Thanks@vishram0709是的，你的代码帮了我很多，而且很容易理解！然而，埃利亚斯提出了一个很好的观点。@vishram0709：你被投了赞成票，但其他人投了反对票。我不确定你为什么会得到DV，但这与我关于可能出现堆栈溢出的评论一致。我的猜测是有人发现没有人提到堆栈耗尽的危险是你回答-1的理由。注：我没有否决投票。我只反对那些完全错误的答案，并且包含不好的、不实用的答案code@vishram0709当前位置我也投了赞成票，但其他人似乎投了你反对票，不知道为什么。你的回答很有帮助，也很容易理解。继续努力，感谢您的回复！非常有用和信息丰富的感谢，这正是我想要的。非常有用和信息丰富的感谢，这正是我想要的。