Syntax
enum <Pangalan ng Uri ng Enum> {Enumeration_Constant_Element-1,
Enumeration_Constant_Element-2,
Enumeration_Constant_Element-3,
…… .........,
Enumeration_Constant_Element-n,
};
Ang default na halaga ng Enumeration_Constant_Element-1 ay 0, ang halaga ng Enumeration_Constant_Element-2 ay 1, ang halaga ng Enumeration_Constant_Element-3 ay 2, at ang halaga ng Enumeration_Constant_Element-n ay (n-1).
Malalim na Sumisid sa Enum
Ngayon, dahil alam namin ang syntax upang tukuyin ang uri ng bilang ng bilang, tingnan natin ang isang halimbawa:
enumError{
IO_ERROR,
DISK_ERROR,
NETWORK_ERROR
};
Dapat palaging gamitin ang enum keyword upang tukuyin ang uri ng pagpapatala. Kaya, tuwing nais mong tukuyin ang isang uri ng pagpapatala, dapat mong gamitin ang enum keyword dati. Matapos ang enum keyword, dapat kang gumamit ng wastong identifier upang tukuyin ang.
Sa halimbawa sa itaas, itatalaga ng tagatala ang IO_ERROR sa integral na halaga: 0, DISK_ERROR sa integral na halaga: 1 at NETWORK_ERROR sa integral na halaga: 2. Bilang default, ang unang enum-element ay palaging nakatalaga sa halagang 0, ang susunod ang enum-element ay nakatalaga sa halagang 1, at iba pa.
Ang default na pag-uugali na ito ay maaaring mabago kung kinakailangan sa pamamagitan ng pagtatalaga ng pare-parehong integral na halaga nang malinaw, tulad ng sumusunod:
enumError{IO_ERROR= 2,
DISK_ERROR,
NETWORK_ERROR= 8 ,
PRINT_ERROR
};
Sa kasong ito, ang IO_ERROR ay malinaw na nakatalaga sa isang halaga ng 2 ng programmer, ang DISK_ERROR ay itinalaga sa isang halagang 3 ng tagatala, ang NETWORK_ERROR ay malinaw na nakatalaga sa halagang 8 ng programmer, at ang PRINT_ERROR ay itinalaga sa susunod mahalagang halaga ng nakaraang elemento ng enum na NETWORK_ERROR (ibig sabihin, 9) ng tagatala.
Kaya, naiintindihan mo na ngayon kung paano tukuyin ang isang uri ng enumerasyon na tinukoy ng gumagamit sa C. Posible bang ideklara ang isang variable ng uri ng enum (dahil maaari naming ideklara ang isang variable ng uri ng integer)? Oo, ito talaga! Maaari mong ideklara ang variable ng enum tulad ng sumusunod:
enumError Hw_Error;Muli, ang enum ay ang keyword dito, ang Error ay ang uri ng enum, at ang Hw_Error ay isang variable na enum.
Titingnan namin ngayon ang mga sumusunod na halimbawa upang maunawaan ang iba't ibang mga paggamit ng enum:
- Halimbawa 1: Default na paggamit ng kahulugan ng enum
- Halimbawa 2: Paggamit ng pasadyang kahulugan ng enum
- Halimbawa 3: kahulugan ng enum gamit ang pare-pareho na pagpapahayag
- Halimbawa 4: saklaw ng enum
Halimbawa 1: Default na Paggamit ng Kahulugan ng enum
Sa halimbawang ito, malalaman mo kung paano tukuyin ang uri ng pagpapatala na may mga default na pare-pareho na halaga. Aalagaan ng tagatala ang pagtatalaga ng mga default na halaga sa mga elemento ng enum. Sa ibaba, makikita mo ang halimbawa ng programa at ang kaukulang output.
# isama/ * Tukuyin ang uri ng enum * /
enumError{
IO_ERROR,
DISK_ERROR,
NETWORK_ERROR
};
intpangunahing()
{
enumError Hw_Error; / * Lumilikha ng variable ng enum * /
printf ('Pagtatakda ng Hw_Error sa IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
printf (' nItinatakda ang Hw_Error sa DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
printf (' nItinatakda ang Hw_Error sa NETWORK_ERROR n');
Hw_Error=NETWORK_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
bumalik ka 0;
}
Halimbawa 2: Paggamit ng Pasadyang enum na Kahulugan
Sa halimbawang ito, malalaman mo kung paano tukuyin ang uri ng pagpapatala na may isang pasadyang pare-parehong halaga. Gayundin, makakatulong sa iyo ang halimbawang ito na maunawaan kung paano maaaring gawin ang pasadyang pagpapasimula ng pasadya sa anumang random na pagkakasunud-sunod. Sa halimbawang ito, malinaw na tinukoy namin ang patuloy na halaga para sa 1stat 3rdmga elemento ng enum (ibig sabihin, IO_ERROR at NETWORK_ERROR, ayon sa pagkakabanggit), ngunit nilaktawan namin ang tahasang pagsisimula para sa 2ndat 4ikamga elemento. Responsibilidad ngayon ng tagatala na italaga ang mga default na halaga sa 2ndat 4ikamga elemento ng enum (ibig sabihin, DISK_ERROR at PRINT_ERROR, ayon sa pagkakabanggit). Ang DISK_ERROR ay itatalaga sa halagang 3 at ang PRINT_ERROR ay itatalaga sa halagang 9. Sa ibaba, makikita mo ang halimbawang programa at ang output.
# isama/ * Tukuyin ang uri ng enum - Pasadyang pagpapasimula * /
enumError{
IO_ERROR= 2,
DISK_ERROR,
NETWORK_ERROR= 8,
PRINT_ERROR
};
intpangunahing()
{
/ * Ideklara ang variable ng enum * /
enumError Hw_Error;
printf ('Pagtatakda ng Hw_Error sa IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
printf (' nItinatakda ang Hw_Error sa DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
printf (' nItinatakda ang Hw_Error sa NETWORK_ERROR n');
Hw_Error=NETWORK_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
printf (' nItinatakda ang Hw_Error sa PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
bumalik ka 0;
}
Halimbawa 3: Kahulugan ng Enum Gamit ang Patuloy na Pagpapahayag
Sa halimbawang ito, matututunan mo kung paano gamitin ang pare-pareho na pagpapahayag upang tukuyin ang patuloy na halaga para sa mga elemento ng enum.
# isama/ * Tukuyin ang uri ng enum - pasadyang pagpapasimula gamit ang pare-pareho na pagpapahayag
ginagamit ang pare-pareho na pagpapahayag dito sa kaso ng:
a. IO_ERROR at
b. NETWORK_ERROR
Ito ay isang hindi pangkaraniwang paraan ng pagtukoy sa mga elemento ng enum; gayunpaman, ito
ipinapakita ng programa na ang ganitong paraan ng pagpapasimula ng mga elemento ng enum ay posible sa c.
* /
enumError{
IO_ERROR= 1 + 2 * 3 + 4,
DISK_ERROR,
NETWORK_ERROR= 2 == 2,
PRINT_ERROR
};
intpangunahing()
{
/ * Ideklara ang variable ng enum * /
enumError Hw_Error;
printf ('Pagtatakda ng Hw_Error sa IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
printf (' nItinatakda ang Hw_Error sa DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
printf (' nItinatakda ang Hw_Error sa NETWORK_ERROR n');
Hw_Error=NETWORK_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
printf (' nItinatakda ang Hw_Error sa PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
bumalik ka 0;
}
Halimbawa 4: Saklaw ng enum
Sa halimbawang ito, malalaman mo kung paano gumagana ang panuntunang scoping para sa enum. Ang isang MACRO (#define) ay maaaring magamit upang tukuyin ang isang pare-pareho sa halip na ang enum, ngunit ang panuntunan sa scoping ay hindi gagana para sa MACRO.
# isamaintpangunahing()
{
/ * Tukuyin ang uri ng enum * /
enumError_1{
IO_ERROR= 10,
DISK_ERROR,
NETWORK_ERROR= 3,
PRINT_ERROR
};
{
/ * Tukuyin ang uri ng enum sa panloob na saklaw * /
enumError_1{
IO_ERROR= dalawampu,
DISK_ERROR,
NETWORK_ERROR= 35,
PRINT_ERROR
};
/ * Ideklara ang variable ng enum * /
enumError_1 Hw_Error;
printf ('Pagtatakda ng Hw_Error sa IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
printf (' nItinatakda ang Hw_Error sa DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
printf (' nItinatakda ang Hw_Error sa NETWORK_ERROR n');
Hw_Error=NETWORK_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
printf (' nItinatakda ang Hw_Error sa PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Halaga ng Hw_Error =% d n',Hw_Error);
}
bumalik ka 0;
}
Paghahambing sa Pagitan ng enum at macro
| Enum | Macro |
| Nalalapat ang panuntunan sa saklaw para sa enum. | Hindi naaangkop para sa Macro ang panuntunan sa saklaw. |
| Awtomatikong nangyayari ang pagtatalaga ng default na Enum na halaga. Nakatutulong ang Enum sa pagtukoy ng isang malaking bilang ng mga pare-pareho. Kinukuha ng tagatala ang default na pare-pareho ang pagpapasimula ng halaga. | Ang mga halaga ng pare-pareho ng macro ay dapat palaging mababanggit nang malinaw ng programmer. Maaari itong maging isang nakakapagod na proseso para sa isang malaking bilang ng mga pare-pareho dahil dapat palaging mano-manong tinukoy ng programmer ang bawat pare-pareho na halaga habang tinutukoy ang Macro. |
Konklusyon
Ang enum na programa sa C ay maaaring maituring na isang opsyonal na pamamaraan para sa mga nakapag-iisang programa o maliliit na proyekto dahil ang mga programmer ay maaaring palaging gumamit ng macro sa halip na isang enum. Gayunpaman, ang mga may karanasan na programmer ay may posibilidad na gumamit ng enum sa macro para sa mga malalaking proyekto sa pag-unlad ng software. Nakakatulong ito sa pagsusulat ng malinis at nababasa na mga programa.