C中的結構陣列

Question

我會如何將這些代碼轉換爲包含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 ; 
} 

Answer 1

你想要做什麼，是創建一個數組，像任何其他數組：

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指定。 see it in action

堆棧溢出：
你要知道，你可能會發現，像這樣的陣列可能會耗盡堆棧存儲器。在這種情況下，您會發現自己可以使用指向結構的指針數組或指針指針。如果你不熟悉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_houses函數。這是它變得有點棘手：

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的記憶，一旦你用它做：

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

避免MEM-泄漏。
再次，this codepad可以作爲一個工作示例

Answer 2

你可以聲明結構數組作爲

houset house[25]; 

，並從main函數調用它

show_house (house[i]); 

Answer 3

這幾乎是與通常的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] = { 
    { 1990, 12180, 5 }, 
    { 1991, 12178, 6 }, 
    /* ... */ 
} 

如果初始化少於25層人的結構將用零填充。

Answer 4

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

Answer 5

我想你問的東西，像

household_t house_info[size*]; 

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

Answer 6

請看看下面的代碼。我希望這個概念簡單易懂。 如果您在發表評論時遇到任何困難。

#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 ; 
} 

Answer 7

創建結構的數組，並通過每一個或所有這些，如果你想，到show_house功能 如houset something[number]，那麼你將它傳遞給秀屋函數