వాక్యనిర్మాణం
ఎనమ్ <ఎనమ్ రకం పేరు> {గణన_కాంస్టెంట్_ఎలిమెంట్-1,
గణన_కాంస్టెంట్_ఎలిమెంట్-2,
గణన_కాంస్టెంట్_ఎలిమెంట్-3,
……………,
గణన_కాంస్టెంట్_ఎలిమెంట్-ఎన్,
};
Enumeration_Constant_Element-1 యొక్క డిఫాల్ట్ విలువ 0, Enumeration_Constant_Element-2 యొక్క విలువ 1, Enumeration_Constant_Element-3 విలువ 2, మరియు Enumeration_Constant_Element-n విలువ (n-1).
ఎనమ్‌లోకి డీప్ డైవ్
ఇప్పుడు, గణన రకాన్ని నిర్వచించడానికి వాక్యనిర్మాణం మాకు తెలుసు కాబట్టి, ఒక ఉదాహరణను చూద్దాం:
ఎనమ్లోపం{
IO_ERROR,
DISK_ERROR,
నెట్వర్క్ లోపం
};
గణన రకాన్ని నిర్వచించడానికి ఎనమ్ కీవర్డ్ ఎల్లప్పుడూ ఉపయోగించాలి. కాబట్టి, మీరు ఎన్యూమరేషన్ రకాన్ని నిర్వచించాలనుకున్నప్పుడు, మీరు తప్పనిసరిగా ముందుగా ఎనమ్ కీవర్డ్‌ని ఉపయోగించాలి. ఎనమ్ కీవర్డ్ తర్వాత, నిర్వచించడానికి మీరు తప్పనిసరిగా చెల్లుబాటు అయ్యే ఐడెంటిఫైయర్‌ని ఉపయోగించాలి.
పై ఉదాహరణలో, కంపైలర్ IO_ERROR ని సమగ్ర విలువకు కేటాయిస్తుంది: 0, DISK_ERROR సమగ్ర విలువకు: 1 మరియు NETWORK_ERROR సమగ్ర విలువకు: 2. డిఫాల్ట్‌గా, మొదటి ఎనమ్-మూలకం ఎల్లప్పుడూ విలువ 0 కేటాయించబడుతుంది, తదుపరిది enum- మూలకం విలువ 1 కి కేటాయించబడుతుంది, మరియు అందువలన న.
ఈ డిఫాల్ట్ ప్రవర్తన అవసరమైతే స్థిరమైన సమగ్ర విలువను స్పష్టంగా కేటాయించడం ద్వారా మార్చవచ్చు, కింది విధంగా:
ఎనమ్లోపం{IO_ERROR= 2,
DISK_ERROR,
నెట్వర్క్ లోపం= 8 ,
PRINT_ERROR
};
ఈ సందర్భంలో, IO_ERROR ప్రోగ్రామర్ ద్వారా 2 విలువకు స్పష్టంగా కేటాయించబడుతుంది, DISK_ERROR కంపైలర్ ద్వారా 3 విలువకు కేటాయించబడుతుంది, NETWORK_ERROR ప్రోగ్రామర్ ద్వారా 8 విలువకు స్పష్టంగా కేటాయించబడుతుంది మరియు PRINT_ERROR తదుపరి వారికి కేటాయించబడుతుంది కంపైలర్ ద్వారా మునుపటి ఎనమ్ మూలకం NETWORK_ERROR (అంటే 9) యొక్క సమగ్ర విలువ.
కాబట్టి, C. లో వినియోగదారు నిర్వచించిన గణన రకాన్ని ఎలా నిర్వచించాలో ఇప్పుడు మీకు అర్థమైంది. అవును, అది! మీరు ఈ క్రింది విధంగా ఎనమ్ వేరియబుల్‌ని ప్రకటించవచ్చు:
ఎనమ్లోపం Hw_Error;మళ్ళీ, ఎనమ్ అనేది ఇక్కడ కీవర్డ్, లోపం ఎనమ్ రకం, మరియు Hw_Error అనేది ఎనమ్ వేరియబుల్.
ఎనమ్ యొక్క వివిధ ఉపయోగాలను అర్థం చేసుకోవడానికి మేము ఇప్పుడు క్రింది ఉదాహరణలను చూస్తాము:
- ఉదాహరణ 1: డిఫాల్ట్ ఎనమ్ డెఫినిషన్ వినియోగం
- ఉదాహరణ 2: కస్టమ్ ఎనమ్ డెఫినిషన్ వినియోగం
- ఉదాహరణ 3: స్థిరమైన వ్యక్తీకరణను ఉపయోగించి ఎనమ్ నిర్వచనం
- ఉదాహరణ 4: ఎనమ్ స్కోప్
ఉదాహరణ 1: డిఫాల్ట్ ఎనమ్ నిర్వచనం వినియోగం
ఈ ఉదాహరణలో, డిఫాల్ట్ స్థిరమైన విలువలతో గణన రకాన్ని ఎలా నిర్వచించాలో మీరు నేర్చుకుంటారు. ఎనమ్ మూలకాలకు డిఫాల్ట్ విలువలను కేటాయించేలా కంపైలర్ జాగ్రత్త తీసుకుంటుంది. క్రింద, మీరు ఉదాహరణ ప్రోగ్రామ్ మరియు సంబంధిత అవుట్‌పుట్ చూస్తారు.
#చేర్చండి/ * ఎనమ్ రకాన్ని నిర్వచించండి */
ఎనమ్లోపం{
IO_ERROR,
DISK_ERROR,
నెట్వర్క్ లోపం
};
intప్రధాన()
{
ఎనమ్లోపం Hw_Error; /* ఎనమ్ వేరియబుల్ సృష్టించడం*/
printf ('Hw_Error ని IO_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=IO_ERROR;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
printf (' nHw_Error ని DISK_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=DISK_ERROR;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
printf (' nHW_Error ని NETWORK_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=నెట్వర్క్ లోపం;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
తిరిగి 0;
}
ఉదాహరణ 2: కస్టమ్ ఎనమ్ నిర్వచనం వినియోగం
ఈ ఉదాహరణలో, అనుకూల స్థిరమైన విలువతో గణన రకాన్ని ఎలా నిర్వచించాలో మీరు నేర్చుకుంటారు. అలాగే, ఏవైనా యాదృచ్ఛిక క్రమంలో అనుకూల స్థిరాంకాల ప్రారంభాన్ని ఎలా చేయవచ్చో అర్థం చేసుకోవడానికి ఈ ఉదాహరణ మీకు సహాయం చేస్తుంది. ఈ ఉదాహరణలో, మేము 1 కోసం స్థిరమైన విలువను స్పష్టంగా నిర్వచించాముసెయింట్మరియు 3rdఎనమ్ అంశాలు (అనగా, IO_ERROR మరియు NETWORK_ERROR, వరుసగా), కానీ మేము 2 కోసం స్పష్టమైన ప్రారంభాన్ని దాటవేసాముndమరియు 4వఅంశాలు. డిఫాల్ట్ విలువలను 2 కి కేటాయించడం ఇప్పుడు కంపైలర్ యొక్క బాధ్యతndమరియు 4వఎనమ్ అంశాలు (అనగా, DISK_ERROR మరియు PRINT_ERROR, వరుసగా). DISK_ERROR 3 విలువకు కేటాయించబడుతుంది మరియు PRINT_ERROR 9. విలువకు కేటాయించబడుతుంది. క్రింద, మీరు ఉదాహరణ ప్రోగ్రామ్ మరియు అవుట్‌పుట్ చూస్తారు.
#చేర్చండి/* ఎనమ్ రకాన్ని నిర్వచించండి - అనుకూల ప్రారంభించడం*/
ఎనమ్లోపం{
IO_ERROR= 2,
DISK_ERROR,
నెట్వర్క్ లోపం= 8,
PRINT_ERROR
};
intప్రధాన()
{
/* ఎనమ్ వేరియబుల్ ప్రకటించండి*/
ఎనమ్లోపం Hw_Error;
printf ('Hw_Error ని IO_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=IO_ERROR;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
printf (' nHw_Error ని DISK_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=DISK_ERROR;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
printf (' nHW_Error ని NETWORK_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=నెట్వర్క్ లోపం;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
printf (' nHw_Error ని PRINT_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=PRINT_ERROR;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
తిరిగి 0;
}
ఉదాహరణ 3: స్థిరమైన వ్యక్తీకరణను ఉపయోగించి ఎనమ్ నిర్వచనం
ఈ ఉదాహరణలో, ఎనమ్ మూలకాల కోసం స్థిరమైన విలువను నిర్వచించడానికి స్థిరమైన వ్యక్తీకరణను ఎలా ఉపయోగించాలో మీరు నేర్చుకుంటారు.
#చేర్చండి/* ఎనమ్ రకాన్ని నిర్వచించండి - స్థిరమైన వ్యక్తీకరణను ఉపయోగించి అనుకూల ప్రారంభించడం
ఇక్కడ స్థిరమైన వ్యక్తీకరణ ఉపయోగించబడుతుంది:
a IO_ERROR మరియు
బి. నెట్వర్క్ లోపం
ఎనమ్ ఎలిమెంట్‌లను నిర్వచించడానికి ఇది అసాధారణమైన మార్గం; అయితే, ఇది
c లో ఎనమ్ ఎలిమెంట్స్ ప్రారంభించడం ఈ విధంగా సాధ్యమవుతుందని ప్రోగ్రామ్ చూపిస్తుంది.
* /
ఎనమ్లోపం{
IO_ERROR= 1 + 2 * 3 + 4,
DISK_ERROR,
నెట్వర్క్ లోపం= 2 == 2,
PRINT_ERROR
};
intప్రధాన()
{
/* ఎనమ్ వేరియబుల్ ప్రకటించండి*/
ఎనమ్లోపం Hw_Error;
printf ('Hw_Error ని IO_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=IO_ERROR;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
printf (' nHw_Error ని DISK_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=DISK_ERROR;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
printf (' nHW_Error ని NETWORK_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=నెట్వర్క్ లోపం;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
printf (' nHw_Error ని PRINT_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=PRINT_ERROR;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
తిరిగి 0;
}
ఉదాహరణ 4: ఎనమ్ స్కోప్
ఈ ఉదాహరణలో, ఎనమ్ కోసం స్కోపింగ్ నియమం ఎలా పనిచేస్తుందో మీరు నేర్చుకుంటారు. ఎనమ్‌కు బదులుగా స్థిరాంకాన్ని నిర్వచించడానికి మాక్రో (#నిర్వచించండి) ఉపయోగించబడవచ్చు, అయితే స్కోపింగ్ నియమం MACRO కోసం పనిచేయదు.
#చేర్చండిintప్రధాన()
{
/ * ఎనమ్ రకాన్ని నిర్వచించండి */
ఎనమ్లోపం_1{
IO_ERROR= 10,
DISK_ERROR,
నెట్వర్క్ లోపం= 3,
PRINT_ERROR
};
{
/* లోపలి పరిధిలో ఎనమ్ రకాన్ని నిర్వచించండి*/
ఎనమ్లోపం_1{
IO_ERROR= ఇరవై,
DISK_ERROR,
నెట్వర్క్ లోపం= 35,
PRINT_ERROR
};
/* ఎనమ్ వేరియబుల్ ప్రకటించండి*/
ఎనమ్లోపం_1 Hw_ లోపం;
printf ('Hw_Error ని IO_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=IO_ERROR;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
printf (' nHw_Error ని DISK_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=DISK_ERROR;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
printf (' nHW_Error ని NETWORK_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=నెట్వర్క్ లోపం;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
printf (' nHw_Error ని PRINT_ERROR కి సెట్ చేస్తోంది n');
Hw_ లోపం=PRINT_ERROR;
printf ('Hw_Error విలువ = %d n',Hw_ లోపం);
}
తిరిగి 0;
}
ఎనమ్ మరియు స్థూల మధ్య పోలిక
| ఎనమ్ | మాక్రో |
| ఎనమ్ కోసం స్కోపింగ్ నియమం వర్తిస్తుంది. | మాక్రో కోసం స్కోపింగ్ నియమం వర్తించదు. |
| డిఫాల్ట్ ఎనమ్ విలువ కేటాయింపు స్వయంచాలకంగా జరుగుతుంది. పెద్ద సంఖ్యలో స్థిరాంకాలను నిర్వచించడంలో ఎనమ్ చాలా సహాయకారిగా ఉంటుంది. కంపైలర్ డిఫాల్ట్ స్థిరమైన విలువ ప్రారంభాన్ని తీసుకుంటుంది. | స్థూల స్థిరమైన విలువలు ఎల్లప్పుడూ ప్రోగ్రామర్ ద్వారా స్పష్టంగా పేర్కొనబడాలి. మాక్రోను నిర్వచించేటప్పుడు ప్రోగ్రామర్ ఎల్లప్పుడూ ప్రతి స్థిరమైన విలువను మాన్యువల్‌గా నిర్వచించాల్సి ఉంటుంది కాబట్టి ఇది పెద్ద సంఖ్యలో స్థిరాంకాల కోసం ఒక దుర్భరమైన ప్రక్రియ కావచ్చు. |
ముగింపు
C లోని ఎనమ్ ప్రోగ్రామ్‌ను స్వతంత్ర ప్రోగ్రామ్‌లు లేదా చిన్న-పరిమాణ ప్రాజెక్ట్‌లకు ఐచ్ఛిక పద్ధతిగా పరిగణించవచ్చు, ఎందుకంటే ప్రోగ్రామర్లు ఎల్లప్పుడూ ఎనమ్‌కు బదులుగా మాక్రోను ఉపయోగించవచ్చు. అయితే, అనుభవజ్ఞులైన ప్రోగ్రామర్లు పెద్ద-స్థాయి సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ ప్రాజెక్ట్‌ల కోసం మాక్రోపై ఎనమ్‌ను ఉపయోగిస్తున్నారు. ఇది క్లీన్ మరియు రీడబుల్ ప్రోగ్రామ్‌లను రాయడంలో సహాయపడుతుంది.