தொடரியல்:
யூனியன் என்பது பயனரால் வரையறுக்கப்படும் ஒரு வகையாகும், இது பகிரப்பட்ட நினைவக இருப்பிடத்தில் பல்வேறு தரவு வகைகளை சேமிப்பதை செயல்படுத்துகிறது. ஒரு யூனியனைப் பயன்படுத்துவது ஒரு struct ஐ ஒத்த தொடரியல் பின்பற்றுகிறது.
அடிப்படை தொடரியல் பின்வருமாறு:
தொழிற்சங்கம் யூனியன் பெயர் {
// உறுப்பினர் அறிவிப்புகள்
DataType1 உறுப்பினர்1 ;
DataType2 உறுப்பினர்2 ;
//...
} ;
இங்கே, 'UnionName' என்பது யூனியனுக்கான அடையாளங்காட்டியாக செயல்படுகிறது, இது குறிப்பிட்ட பயனர் வரையறுக்கப்பட்ட வகையைக் குறிப்பிடுவதற்கு ஒரு தனித்துவமான பெயரை வழங்குகிறது. தொழிற்சங்க உறுப்பினர்களின் தரவு வகைகள் 'DataType1', 'DataType2' மற்றும் பலவாகக் குறிக்கப்படுகின்றன. இந்த தரவு வகைகள் தொழிற்சங்கத்திற்குள் சேமிக்கக்கூடிய பல்வேறு வகையான தகவல்களைக் குறிக்கின்றன. 'உறுப்பினர்1', 'உறுப்பினர்2' போன்ற பெயர்களால் நியமிக்கப்பட்ட தொழிற்சங்கத்தில் உள்ள ஒவ்வொரு உறுப்பினரும் தனித்தனியான தரவைக் குறிக்கின்றனர்.
நாம் இப்போது அடிப்படை தொடரியல் புரிந்து கொள்கிறோம். இதை நன்றாகப் புரிந்துகொள்ள இப்போது சில நிகழ்வுகளைப் பயன்படுத்துவோம்.
எடுத்துக்காட்டு 1: அடிப்படை யூனியன் பயன்பாடு
முதல் உதாரணம் C++ இல் உள்ள தொழிற்சங்கங்களின் அடிப்படைப் பயன்பாட்டை விளக்குகிறது, ஒரே கட்டமைப்பிற்குள் வெவ்வேறு தரவு வகைகளுக்கு இடையே நினைவக இடத்தைப் பகிர்வதை அவை எவ்வாறு செயல்படுத்துகின்றன என்பதைக் காட்டுகிறது.
இங்கே ஒரு உதாரணம்:
#
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
தொழிற்சங்கம் வரிசையூனியன் {
முழு எண்ணாக intArray [ 5 ] ;
மிதவை floatArray [ 5 ] ;
} ;
முழு எண்ணாக முக்கிய ( ) {
ArrayUnion arrayUnion ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < 5 ; ++ நான் ) {
வரிசையூனியன். intArray [ நான் ] = நான் * 2 ;
}
கூட் << 'இன்ட் அரே:' ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < 5 ; ++ நான் ) {
கூட் << '' << வரிசையூனியன். intArray [ நான் ] ;
}
கூட் << endl ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < 5 ; ++ நான் ) {
வரிசையூனியன். floatArray [ நான் ] = நான் * 1.5f ;
}
கூட் << 'ஃப்ளோட் அரே:' ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < 5 ; ++ நான் ) {
கூட் << '' << வரிசையூனியன். floatArray [ நான் ] ;
}
கூட் << endl ;
திரும்ப 0 ;
}
இந்த C++ குறியீடு துணுக்கில், மூன்று வெவ்வேறு தரவு உறுப்பினர்களை உள்ளடக்கிய 'MyUnion' என்ற யூனியனைப் பயன்படுத்துகிறோம்: ஒரு முழு எண் (intValue), ஒரு மிதக்கும் புள்ளி எண் (floatValue) மற்றும் ஒரு எழுத்து (charValue). நினைவக இடத்தைப் பகிர்ந்து கொள்ளும் தொழிற்சங்கத்தின் திறன் காரணமாக இந்த உறுப்பினர்களில் ஒருவர் மட்டுமே எந்த நேரத்திலும் செயலில் இருக்கலாம்.
'முக்கிய' செயல்பாட்டிற்குள், 'myUnion' என்ற தொழிற்சங்கத்தின் ஒரு நிகழ்வை நாங்கள் அறிவிக்கிறோம். முதலில், முழு எண் உறுப்பினரின் மதிப்பை 42 ஆக அமைத்து அதை அச்சிட 'cout' ஐப் பயன்படுத்துகிறோம். பின்னர், மிதக்கும் புள்ளி மதிப்பான 3.14ஐ “floatValue” உறுப்பினருக்கு ஒதுக்கி அச்சிடுவோம். கடைசியாக, “charValue” உறுப்பினருக்கு “A” என்ற எழுத்தை ஒதுக்கி அச்சிடுகிறோம். அனைத்து யூனியன் உறுப்பினர்களும் ஒரே நினைவக இருப்பிடத்தைப் பகிர்ந்து கொள்வதால், ஒரு உறுப்பினரை மாற்றுவது மற்ற உறுப்பினர்களின் மதிப்புகளில் தாக்கத்தை ஏற்படுத்தக்கூடும் என்பதை நினைவில் கொள்வது அவசியம். வெற்றிகரமான செயல்படுத்தலைக் குறிக்கும் 0 ஐ வழங்குவதன் மூலம் குறியீடு முடிவடைகிறது.
எடுத்துக்காட்டு 2: யூனியன் வித் ஸ்ட்ரக்ட்
ஒரு struct என்பது C++ இல் உள்ள ஒரு வகை தரவு ஆகும், இது ஒரு ஒருங்கிணைந்த பெயரில் பல்வேறு வகைகளின் மாறிகளை இணைக்க பயனர்கள் உருவாக்க முடியும். வெவ்வேறு வகையான தரவுகளை வைத்திருக்கக்கூடிய தரவு கட்டமைப்பை உருவாக்க விரும்பும்போது, ஒவ்வொரு வகையும் ஒரு குறிப்பிட்ட புலத்துடன் தொடர்புடையதாக இருக்கும் போது, யூனியனை ஒரு கட்டமைப்புடன் இணைப்பது பயனுள்ளதாக இருக்கும். இந்த இணைத்தல் பல்வேறு பிரதிநிதித்துவங்களைக் கொண்ட சிக்கலான தரவு கட்டமைப்புகளை உருவாக்க அனுமதிக்கிறது.
C++ இல் உள்ள கட்டமைப்பிற்குள் யூனியனைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு இங்கே:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
கட்டமைக்க புள்ளி {
முழு எண்ணாக s1 ;
முழு எண்ணாக s2 ;
} ;
தொழிற்சங்கம் வடிவம் {
முழு எண்ணாக பக்கங்களிலும் ;
மிதவை ஆரம் ;
புள்ளி மையம் ;
} ;
முழு எண்ணாக முக்கிய ( ) {
வடிவ வடிவம் ;
வடிவம். பக்கங்களிலும் = 5 ;
கூட் << 'பக்கங்கள்:' << வடிவம். பக்கங்களிலும் << endl ;
வடிவம். ஆரம் = 6.0f ;
கூட் << 'ஆரம்:' << வடிவம். ஆரம் << endl ;
வடிவம். மையம் = { 10 , இருபது } ;
கூட் << 'மையம்: (' << வடிவம். மையம் . s1 << ',' << வடிவம். மையம் . s2 << ')' << endl ;
திரும்ப 0 ;
}
இந்தக் குறியீட்டில், வடிவியல் வடிவத்தின் வெவ்வேறு அம்சங்களைப் பிரதிநிதித்துவப்படுத்த ஒரு யூனியன் மற்றும் ஒரு struct ஐப் பயன்படுத்தும் C++ நிரலை நாங்கள் வரையறுக்கிறோம். முதலில், 2D இடத்தில் ஒரு புள்ளியின் ஆயத்தொலைவுகளைக் குறிக்கும் 's1' மற்றும் 's2' ஆகிய இரண்டு முழு எண் உறுப்பினர்களைக் கொண்ட 'புள்ளி' கட்டமைப்பை அறிவிக்கிறோம். பின்னர், மூன்று உறுப்பினர்களைக் கொண்ட 'வடிவம்' என்ற பெயரிடப்பட்ட 'யூனியன்' ஒன்றை வரையறுக்கிறோம்: ஒரு 'பக்கங்கள்' முழு எண், 'ஆரம்' மிதக்கும் புள்ளி மற்றும் 'மையம்' என்று பெயரிடப்பட்ட 'புள்ளி' அமைப்பு. 'முக்கிய' செயல்பாட்டிற்குச் செல்லும்போது, 'வடிவம்' என்று பெயரிடப்பட்ட 'வடிவ' பொருளைத் துரிதப்படுத்துகிறோம். அதன் வெவ்வேறு உறுப்பினர்களுக்கு மதிப்புகளை வழங்குவதன் மூலம் தொழிற்சங்கத்தின் பல்துறைத்திறனை நாங்கள் நிரூபிக்கிறோம். ஆரம்பத்தில், பக்கங்களின் எண்ணிக்கையை 5 ஆக அமைத்து முடிவை அச்சிடுகிறோம். அடுத்து, வடிவத்திற்கு 6.0 ஆரம் ஒதுக்குகிறோம் மற்றும் ஆரம் வெளியிடுகிறோம். இறுதியாக, வடிவத்திற்கு ஆய (10, 20) மையப் புள்ளியை ஒதுக்கி மையத்தின் ஆயங்களை அச்சிடுகிறோம்.
எடுத்துக்காட்டு 3: எனுமுடன் ஒன்றியம்
C++ இல், பொதுவாக enums என குறிப்பிடப்படும் எண்கள், பெயரிடப்பட்ட ஒருங்கிணைந்த மாறிலிகளின் தொகுப்பை வரையறுக்கும் நோக்கத்திற்காக சேவை செய்கின்றன. தொழிற்சங்கங்களுடன் enumகளை இணைப்பது பயனுள்ளதாக இருக்கும், அங்கு நாம் வெவ்வேறு வகைகளை எடுக்கக்கூடிய ஒரு மாறியைப் பிரதிநிதித்துவப்படுத்த விரும்புகிறோம், ஒவ்வொன்றும் ஒரு குறிப்பிட்ட enum மதிப்புடன் தொடர்புடையது.
இங்கே ஒரு உதாரணம்:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
enum தரவு வகை {
முழு ,
மிதவை ,
சார்
} ;
தொழிற்சங்கம் தரவு மதிப்பு {
முழு எண்ணாக intValue ;
மிதவை மிதவை மதிப்பு ;
கரி சார் மதிப்பு ;
} ;
கட்டமைக்க தகவல்கள் {
தரவு வகை வகை ;
தரவு மதிப்பு மதிப்பு ;
} ;
முழு எண்ணாக முக்கிய ( )
{
தரவு தரவு1 , தரவு2 , தரவு3 ;
தரவு1. வகை = முழு ;
தரவு1. மதிப்பு . intValue = 42 ;
தரவு2. வகை = மிதவை ;
தரவு2. மதிப்பு . மிதவை மதிப்பு = 3.14f ;
தரவு3. வகை = சார் ;
தரவு3. மதிப்பு . சார் மதிப்பு = 'ஏ' ;
கூட் << 'தரவு 1:' << தரவு1. மதிப்பு . intValue << endl ;
கூட் << 'தரவு 2:' << தரவு2. மதிப்பு . மிதவை மதிப்பு << endl ;
கூட் << 'தரவு 3:' << தரவு3. மதிப்பு . சார் மதிப்பு << endl ;
திரும்ப 0 ;
}
இந்த எடுத்துக்காட்டில், பல்வேறு வகையான மதிப்புகளை வைத்திருக்கும் திறன் கொண்ட நெகிழ்வான தரவு கட்டமைப்பை உருவாக்க, enums, Unions மற்றும் structs ஆகியவற்றைப் பயன்படுத்தும் நிரல் எங்களிடம் உள்ளது. 'DataType' enum என்பது மூன்று அடிப்படை தரவு வகைகளைக் குறிக்க வரையறுக்கப்பட்டுள்ளது: INTEGER, FLOAT மற்றும் CHAR. பெயரிடப்பட்ட ஒருங்கிணைந்த மாறிலிகளின் தொகுப்பை வழங்குவதன் மூலம் enum குறியீடு வாசிப்புத்திறன் மற்றும் பராமரிப்பை மேம்படுத்துகிறது.
பின்னர், மூன்று உறுப்பினர்களைக் கொண்ட 'DataValue' எனப்படும் ஒரு யூனியனை உருவாக்குகிறோம்: 'charValue' வகை கரி, 'floatValue' வகை மிதவை மற்றும் 'intValue' வகை int. ஒரு தொழிற்சங்கத்துடன், இந்த உறுப்பினர்கள் பொதுவான நினைவக இருப்பிடத்தைப் பகிர்ந்து கொள்கிறார்கள், இது தொழிற்சங்கத்தை வெவ்வேறு வகைகளின் மதிப்புகளை ஒன்றுக்கொன்று மாற்றியமைக்க அனுமதிக்கிறது. 'தரவு' அமைப்பு பின்னர் இரண்டு உறுப்பினர்களைக் கொண்டதாக உருவாக்கப்படுகிறது: 'வகை' என்ற 'டேட்டா டைப்' கணக்காளர் மற்றும் 'மதிப்பு' என்று பெயரிடப்பட்ட 'டேட்டா வேல்யூ' யூனியன். இந்த அமைப்பு ஒரு தரவு வகையை அதனுடன் தொடர்புடைய மதிப்புடன் இணைக்க அனுமதிக்கிறது, இது கட்டமைக்கப்பட்ட பிரதிநிதித்துவத்தை வழங்குகிறது.
'முக்கிய' செயல்பாட்டில், 'தரவு' கட்டமைப்பின் மூன்று நிகழ்வுகளை நாங்கள் உடனடியாக வழங்குகிறோம்: 'data1', 'data2' மற்றும் 'data3'. தரவு வகையைக் குறிப்பிட்டு யூனியனுக்குள் பொருத்தமான மதிப்பை அமைப்பதன் மூலம் இந்த நிகழ்வுகளுக்கு மதிப்புகளை ஒதுக்குகிறோம். எடுத்துக்காட்டாக, “data1” ஆனது INTEGER வகையுடன் 42 மதிப்புடன் ஒதுக்கப்பட்டுள்ளது. இறுதியாக, ஒவ்வொரு “டேட்டா” நிகழ்விலும் சேமிக்கப்படும் மதிப்புகளை அச்சிட “cout” அறிக்கைகளைப் பயன்படுத்துகிறோம். நிரல் 'data1' இன் முழு எண் மதிப்பு, 'data2' இன் மிதக்கும் புள்ளி மதிப்பு மற்றும் 'data3' இன் எழுத்து மதிப்பை வெளியிடுகிறது.
C++ இல் பல்துறை மற்றும் வகை-பாதுகாப்பான தரவு பிரதிநிதித்துவத்தை உருவாக்க, enums, Unions மற்றும் structs ஆகியவற்றை எவ்வாறு இணைப்பது என்பதை இந்த எடுத்துக்காட்டு விளக்குகிறது.
முடிவுரை
C++ தொழிற்சங்கங்கள், பலதரப்பட்ட தரவு வகைகளை ஒரே நினைவகத்தில் நிர்வகிப்பதற்கான சக்திவாய்ந்த மற்றும் நெகிழ்வான பொறிமுறையை வழங்குகின்றன. இக்கட்டுரையில் விளக்கப்பட்டுள்ள நிகழ்வுகள், பல்வேறு சூழல்களுக்கு தீர்வு காண்பதில் தொழிற்சங்கங்களின் தகவமைப்பு மற்றும் செயல்திறனை எடுத்துக்காட்டுகின்றன. தரவு வகைகளின் பரிமாற்றத்தை நிரூபிக்கும் அடிப்படை பயன்பாடுகளில் இருந்து கட்டமைப்புகள் மற்றும் enumகளை உள்ளடக்கிய மிகவும் சிக்கலான பயன்பாடுகளுக்கு, இந்த எடுத்துக்காட்டுகள் தொழிற்சங்கங்கள் C++ நிரலாக்கத்திற்கு கொண்டு வரும் திறன் மற்றும் பொருந்தக்கூடிய தன்மையை அடிக்கோடிட்டுக் காட்டுகின்றன.