தொடரியல்
enum <எனம் வகை பெயர்> {கணக்கெடுப்பு_காண்டஸ்டன்ட்_எலிமென்ட்-1,
கணக்கெடுப்பு_காண்டஸ்டன்ட்_எலிமென்ட்-2,
கணக்கெடுப்பு_காண்டஸ்டன்ட்_எலிமென்ட்-3,
……………,
கணக்கெடுப்பு_காண்டஸ்டன்ட்_எலிமென்ட்-என்,
};
Enumeration_Constant_Element-1 இன் இயல்புநிலை மதிப்பு 0 ஆகும், Enumeration_Constant_Element-2 இன் மதிப்பு 1 ஆகும், Enumeration_Constant_Element-3 இன் மதிப்பு 2 ஆகும், மேலும் Enumeration_Constant_Element-n இன் மதிப்பு (n-1) ஆகும்.
எனுமில் ஆழமாக மூழ்கிவிடுங்கள்
இப்போது, எண்கணித வகையை வரையறுக்க தொடரியல் நமக்குத் தெரிந்திருப்பதால், ஒரு உதாரணத்தைப் பார்ப்போம்:
enumபிழை{
IO_ERROR,
DISK_ERROR,
NETWORK_ERROR
};
எண்ணும் வகையை வரையறுக்க எனம் முக்கிய சொல் எப்போதும் பயன்படுத்தப்பட வேண்டும். எனவே, நீங்கள் ஒரு கணக்கீட்டு வகையை வரையறுக்க விரும்பும் போதெல்லாம், நீங்கள் முன்பு எனம் முக்கிய வார்த்தையைப் பயன்படுத்த வேண்டும். எனம் முக்கிய வார்த்தைக்குப் பிறகு, நீங்கள் வரையறுக்க சரியான அடையாளங்காட்டியைப் பயன்படுத்த வேண்டும்.
மேலே உள்ள எடுத்துக்காட்டில், தொகுப்பாளர் IO_ERROR ஐ ஒருங்கிணைந்த மதிப்புக்கு ஒதுக்கும்: 0, DISK_ERROR ஒருங்கிணைந்த மதிப்புக்கு: 1 மற்றும் NETWORK_ERROR ஒருங்கிணைந்த மதிப்புக்கு: 2. இயல்பாக, முதல் எண்-உறுப்பு எப்போதும் மதிப்பு 0, அடுத்தது enum- உறுப்புக்கு மதிப்பு 1 ஒதுக்கப்பட்டுள்ளது, மற்றும் பல.
தொடர்ச்சியான ஒருங்கிணைந்த மதிப்பை வெளிப்படையாக ஒதுக்குவதன் மூலம் தேவைப்பட்டால் இந்த இயல்புநிலை நடத்தையை மாற்றலாம், பின்வருமாறு:
enumபிழை{IO_ERROR= 2,
DISK_ERROR,
NETWORK_ERROR= 8 ,
PRINT_ERROR
};
இந்த வழக்கில், IO_ERROR ஆனது புரோகிராமரால் 2 மதிப்புக்கு ஒதுக்கப்பட்டுள்ளது தொகுப்பாளரால் முந்தைய enum உறுப்பு NETWORK_ERROR (அதாவது 9) இன் ஒருங்கிணைந்த மதிப்பு.
எனவே, இப்போது பயனர் வரையறுக்கப்பட்ட எண்கணித வகையை சி. யில் எப்படி வரையறுப்பது என்பதை நீங்கள் புரிந்துகொண்டுள்ளீர்கள். ஆம், அது! நீங்கள் பின்வருமாறு எனம் மாறியை அறிவிக்கலாம்:
enumபிழை Hw_Error;மீண்டும், இங்கு என்பது முக்கிய சொல், பிழை என்பது எனம் வகை, மற்றும் Hw_Error என்பது ஒரு எண் மாறியாகும்.
எனுமின் பல்வேறு பயன்பாடுகளைப் புரிந்துகொள்ள பின்வரும் உதாரணங்களைப் பார்ப்போம்:
- எடுத்துக்காட்டு 1: இயல்புநிலை வரையறை பயன்பாடு
- எடுத்துக்காட்டு 2: தனிப்பயன் எண் வரையறை பயன்பாடு
- எடுத்துக்காட்டு 3: நிலையான வெளிப்பாட்டைப் பயன்படுத்தி எண்ணம் வரையறை
- எடுத்துக்காட்டு 4: enum நோக்கம்
எடுத்துக்காட்டு 1: இயல்புநிலை வரையறை பயன்பாடு
இந்த எடுத்துக்காட்டில், இயல்புநிலை நிலையான மதிப்புகளுடன் எண்ணும் வகையை எவ்வாறு வரையறுப்பது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள். இயல்பான மதிப்புகளை எனம் கூறுகளுக்கு ஒதுக்குவதை கம்பைலர் கவனித்துக்கொள்வார். கீழே, எடுத்துக்காட்டு நிரல் மற்றும் அதனுடன் தொடர்புடைய வெளியீட்டை நீங்கள் காண்பீர்கள்.
#சேர்க்கிறது/ * எனம் வகையை வரையறுக்கவும் */
enumபிழை{
IO_ERROR,
DISK_ERROR,
NETWORK_ERROR
};
intமுக்கிய()
{
enumபிழை 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_ பிழை=NETWORK_ERROR;
printf ('Hw_Error இன் மதிப்பு = %d n',Hw_ பிழை);
திரும்ப 0;
}
எடுத்துக்காட்டு 2: தனிப்பயன் எண் வரையறை பயன்பாடு
இந்த எடுத்துக்காட்டில், தனிப்பயன் நிலையான மதிப்புடன் எண்ணும் வகையை எவ்வாறு வரையறுப்பது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள். மேலும், தனிப்பயன் மாறிலிகள் துவக்கம் எந்த சீரற்ற வரிசையில் எப்படி செய்ய முடியும் என்பதைப் புரிந்துகொள்ள இந்த எடுத்துக்காட்டு உதவும். இந்த எடுத்துக்காட்டில், 1 க்கான நிலையான மதிப்பை நாங்கள் தெளிவாக வரையறுத்துள்ளோம்ஸ்டம்ப்மற்றும் 3ஆர்.டிenum கூறுகள் (அதாவது, முறையே IO_ERROR மற்றும் NETWORK_ERROR), ஆனால் 2 க்கான வெளிப்படையான துவக்கத்தை நாங்கள் தவிர்த்துவிட்டோம்.ndமற்றும் 4வதுகூறுகள் இயல்புநிலை மதிப்புகளை 2 க்கு ஒதுக்குவது இப்போது தொகுப்பாளரின் பொறுப்பாகும்ndமற்றும் 4வதுenum கூறுகள் (அதாவது, முறையே DISK_ERROR மற்றும் PRINT_ERROR). DISK_ERROR ஆனது 3 மதிப்புக்கு ஒதுக்கப்படும் மற்றும் PRINT_ERROR 9. மதிப்புக்கு ஒதுக்கப்படும். கீழே, எடுத்துக்காட்டு நிரல் மற்றும் வெளியீட்டை நீங்கள் காண்பீர்கள்.
#சேர்க்கிறது/* எனம் வகையை வரையறுக்கவும் - தனிப்பயன் துவக்கம்*/
enumபிழை{
IO_ERROR= 2,
DISK_ERROR,
NETWORK_ERROR= 8,
PRINT_ERROR
};
intமுக்கிய()
{
/* எனும் மாறியை அறிவிக்கவும்*/
enumபிழை 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_ பிழை=NETWORK_ERROR;
printf ('Hw_Error இன் மதிப்பு = %d n',Hw_ பிழை);
printf (' nHw_Error ஐ PRINT_ERROR க்கு அமைக்கிறது n');
Hw_ பிழை=PRINT_ERROR;
printf ('Hw_Error இன் மதிப்பு = %d n',Hw_ பிழை);
திரும்ப 0;
}
எடுத்துக்காட்டு 3: நிலையான வெளிப்பாட்டைப் பயன்படுத்தி எண் வரையறை
இந்த எடுத்துக்காட்டில், எனும் கூறுகளுக்கான நிலையான மதிப்பை வரையறுக்க நிலையான வெளிப்பாட்டை எவ்வாறு பயன்படுத்துவது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள்.
#சேர்க்கிறது/* எனம் வகையை வரையறுக்கவும் - நிலையான வெளிப்பாட்டைப் பயன்படுத்தி தனிப்பயன் துவக்கம்
பின்வரும் சந்தர்ப்பங்களில் நிலையான வெளிப்பாடு இங்கே பயன்படுத்தப்படுகிறது:
ஒரு IO_ERROR மற்றும்
b NETWORK_ERROR
எனம் கூறுகளை வரையறுக்க இது ஒரு அசாதாரண வழி; எனினும், இது
enum உறுப்புகள் துவக்கத்தின் இந்த வழி c இல் சாத்தியம் என்பதை நிரல் நிரூபிக்கிறது.
* /
enumபிழை{
IO_ERROR= 1 + 2 * 3 + 4,
DISK_ERROR,
NETWORK_ERROR= 2 == 2,
PRINT_ERROR
};
intமுக்கிய()
{
/* எனும் மாறியை அறிவிக்கவும்*/
enumபிழை 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_ பிழை=NETWORK_ERROR;
printf ('Hw_Error இன் மதிப்பு = %d n',Hw_ பிழை);
printf (' nHw_Error ஐ PRINT_ERROR க்கு அமைக்கிறது n');
Hw_ பிழை=PRINT_ERROR;
printf ('Hw_Error இன் மதிப்பு = %d n',Hw_ பிழை);
திரும்ப 0;
}
உதாரணம் 4: enum Scope
இந்த எடுத்துக்காட்டில், எனுமுக்கு ஸ்கோப்பிங் விதி எவ்வாறு செயல்படுகிறது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள். எனுமுக்குப் பதிலாக ஒரு மாறிலியை வரையறுக்க ஒரு மேக்ரோ (#வரையறுக்கப்பட்டது) பயன்படுத்தப்பட்டிருக்கலாம், ஆனால் ஸ்கோப்பிங் விதி MACRO க்கு வேலை செய்யாது.
#சேர்க்கிறதுintமுக்கிய()
{
/ * எனம் வகையை வரையறுக்கவும் */
enumபிழை_1{
IO_ERROR= 10,
DISK_ERROR,
NETWORK_ERROR= 3,
PRINT_ERROR
};
{
/* உள் நோக்கத்தில் எனம் வகையை வரையறுக்கவும்*/
enumபிழை_1{
IO_ERROR= இருபது,
DISK_ERROR,
NETWORK_ERROR= 35,
PRINT_ERROR
};
/* எனும் மாறியை அறிவிக்கவும்*/
enumபிழை_1 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_ பிழை=NETWORK_ERROR;
printf ('Hw_Error இன் மதிப்பு = %d n',Hw_ பிழை);
printf (' nHw_Error ஐ PRINT_ERROR க்கு அமைக்கிறது n');
Hw_ பிழை=PRINT_ERROR;
printf ('Hw_Error இன் மதிப்பு = %d n',Hw_ பிழை);
}
திரும்ப 0;
}
எனும் மேக்ரோவிற்கும் இடையிலான ஒப்பீடு
| எனும் | மேக்ரோ |
| எனிமிற்கு ஸ்கோப்பிங் விதி பொருந்தும். | மேக்ரோவுக்கு ஸ்கோப்பிங் விதி பொருந்தாது. |
| இயல்பு எனும் மதிப்பு ஒதுக்கீடு தானாக நடக்கும். அதிக எண்ணிக்கையிலான மாறிலிகளை வரையறுப்பதில் எனும் மிகவும் உதவியாக இருக்கும். தொகுப்பி இயல்புநிலை நிலையான மதிப்பு துவக்கத்தை எடுக்கிறது. | மேக்ரோ மாறிலி மதிப்புகள் எப்போதும் புரோகிராமரால் வெளிப்படையாக குறிப்பிடப்பட வேண்டும். மேக்ரோவை வரையறுக்கும் போது புரோகிராமர் எப்போதும் ஒவ்வொரு நிலையான மதிப்பை கைமுறையாக வரையறுக்க வேண்டும் என்பதால் இது அதிக எண்ணிக்கையிலான மாறிலிகளுக்கு ஒரு கடினமான செயல்முறையாக இருக்கலாம். |
முடிவுரை
C இல் உள்ள enum நிரல் தனி நிரல்கள் அல்லது சிறிய அளவிலான திட்டங்களுக்கான ஒரு விருப்ப முறையாகக் கருதப்படலாம், ஏனெனில் புரோகிராமர்கள் எப்போதும் ஒரு enum க்குப் பதிலாக மேக்ரோவைப் பயன்படுத்தலாம். இருப்பினும், அனுபவம் வாய்ந்த புரோகிராமர்கள் பெரிய அளவிலான மென்பொருள் மேம்பாட்டுத் திட்டங்களுக்கு மேக்ரோ மீது எனம் பயன்படுத்த முனைகின்றனர். இது சுத்தமான மற்றும் படிக்கக்கூடிய நிரல்களை எழுத உதவுகிறது.