C++ இல், ஒரு வகுப்பை வரையறுக்கும்போது, அந்த வகுப்பிற்குள் சில மாறிகளை துவக்குகிறோம். இந்த மாறிகள் வகுப்பின் 'உறுப்பினர் மாறி' ஆகும். C++ நிரலாக்கத்தில் உள்ள கன்ஸ்ட்ரக்டர் முறையைப் பயன்படுத்துவதன் மூலம் “உறுப்பினர் மாறியை” துவக்கலாம். ஒரு குறிப்பிட்ட வகுப்பு பொருளுடன் இணைக்கப்பட்ட மற்றும் அதன் அனைத்து முறைகள் அல்லது செயல்பாடுகளுக்கு அணுகக்கூடிய ஒரு மாறியானது C++ இல் 'உறுப்பினர் மாறி' என குறிப்பிடப்படுகிறது. இந்த கட்டுரையில், இந்த “உறுப்பினர் மாறிகளை” C++ குறியீட்டில் அறிவிப்போம், மேலும் “உறுப்பினர் மாறிகள்” பற்றி இங்கு விரிவாக விளக்குவோம்.
எடுத்துக்காட்டு 1:
இந்தக் குறியீட்டின் போது நமக்குத் தேவைப்படும் “தலைப்புக் கோப்பை” சேர்த்து சில குறியீட்டை இங்கே தொடங்கலாம். “iostream” என்பது இந்தக் குறியீட்டில் நாம் செருகும் தலைப்புக் கோப்பு. இந்தக் குறியீட்டில் நமக்குத் தேவையான மற்றும் அதில் அறிவிக்கப்படும் பல செயல்பாடுகளை இந்த ஹெடர் கோப்பில் உள்ளடக்கியது. பின்னர், நாம் பெயர்வெளியை சேர்க்க வேண்டும், அது “std” ஆகும், எனவே “namespace std” உடன் “using” முக்கிய சொல்லை வைப்பதன் மூலம் அதை இங்கே சேர்க்கிறோம்.
இந்த 'std' ஐ செயல்பாடுகளுடன் தனித்தனியாக சேர்க்க தேவையில்லை. பின்னர், 'SampleClass' என்ற வகுப்பை வரையறுத்து, 'பொது' கட்டமைப்பாளரைப் பயன்படுத்துகிறோம். இந்த 'பொது' கன்ஸ்ட்ரக்டரில், சில உறுப்பினர் மாறிகளை நாங்கள் அறிவிக்கிறோம், அதை நாங்கள் பின்னர் எங்கள் உறுப்பினர் செயல்பாடுகளில் அணுகுவோம். நாம் இங்கு அறிவிக்கும் உறுப்பினர் மாறிகள் “int” தரவு வகையின் “mVar1” மற்றும் “mVar2” ஆகும்.
அதன் கீழ், “setValues()” என்று பெயரிடப்பட்ட ஒரு செயல்பாட்டை அறிவிக்கிறோம். இந்த “setValues()” செயல்பாட்டில், இரண்டு மதிப்புகளை உள்ளிடுமாறு பயனருக்கு அறிவுறுத்தும் செய்தியை அச்சிட “cout” ஐ வைக்கிறோம். பயனர் உள்ளிடும் இரண்டு மதிப்புகள் 'mVar1' மற்றும் 'mVar2' மாறிகளில் சேமிக்கப்படும். 'சின்' முறையின் உதவியுடன் இந்த மதிப்புகளைப் பெறுகிறோம். இரண்டு மதிப்புகளையும் பெற்று அவற்றை “mVar1” மற்றும் “mVar2” இல் சேமித்த பிறகு, இதற்குக் கீழே மற்றொரு செயல்பாட்டை வரையறுக்கிறோம். அந்த செயல்பாட்டின் பெயர் 'getValues' ஆகும், அங்கு நாம் 'cout' அறிக்கைகளைப் பயன்படுத்துகிறோம்.
இங்கே, 'mVar1' மற்றும் 'mVar2' ஐ மீண்டும் 'cout' இல் வைக்கிறோம், இது முந்தைய பயனரிடமிருந்து நாம் பெறும் இரண்டு மதிப்புகளையும் காண்பிக்கும். இதன் அடியில், கிளாஸ் ஆப்ஜெக்ட் உருவாக்கப்படும் “முக்கிய()” முறையை அழைக்கிறோம். வகுப்பு பொருளின் பெயர் “sc1”. பின்னர், 'sc1' ஆப்ஜெக்டுடன் நாம் வரையறுக்கும் முதல் செயல்பாட்டை 'setValues' என்று அழைக்கிறோம்.
இதற்குப் பிறகு, பொருளின் பெயரை மீண்டும் வைத்து, 'sc1' ஆப்ஜெக்ட் பெயருடன் 'getValues()' என்ற இரண்டாவது செயல்பாட்டை அழைக்கிறோம். இப்போது, அது முதலில் மதிப்புகளைப் பெறுகிறது, பின்னர் இந்த குறியீட்டில் உறுப்பினர் மாறி அணுகப்பட்ட வகுப்பு பொருளுடன் இரண்டு முறைகளையும் அழைக்கும்போது அவற்றை கன்சோலில் காண்பிக்கும்.
குறியீடு 1:
#பெயர்வெளி std ஐப் பயன்படுத்துதல்;
வகுப்பு மாதிரி வகுப்பு {
பொது:
int mVar1, mVar2;
வெற்றிட தொகுப்பு மதிப்புகள் ( ) {
கூட் <> mVar1 >> mVar2;
}
வெற்றிட மதிப்புகள் ( ) {
கூட் << 'முதல் உறுப்பினர் மாறியின் மதிப்பு =' << mVar1 << endl ;
கூட் << 'இரண்டாம் உறுப்பினர் மாறியின் மதிப்பு =' << mVar2 << endl;
}
} ;
முழு எண்ணாக ( )
{
SampleClass sc1;
sc1.setValues ( ) ;
sc1.getValues ( ) ;
திரும்ப 0 ;
}
வெளியீடு:
இது முதலில் செய்தியை அச்சிடுகிறது. பின்னர், '12' மற்றும் '456' ஐ உள்ளீட்டு மதிப்புகளாக உள்ளிடுகிறோம், அவை குறியீட்டில் நாங்கள் அறிவித்த உறுப்பினர் மாறிகளில் சேமிக்கப்படும். பின்னர், உறுப்பினர் செயல்பாட்டைப் பயன்படுத்தி நாம் அவற்றை அணுகும்போது இரு மாறிகளின் மதிப்புகளையும் இது காட்டுகிறது.
எடுத்துக்காட்டு 2:
இப்போது, “iostream” தலைப்புக் கோப்பு மற்றும் “std” பெயர்வெளியைச் சேர்த்த பிறகு “ProductClass” என்ற வகுப்பை வரையறுக்கிறோம். இந்த 'ProductClass' இல், 'பொது' கட்டமைப்பாளரைப் பயன்படுத்துகிறோம், அதில் 'int' தரவு வகையின் இரண்டு மாறிகளை அறிவிக்கிறோம். இவை 'மதிப்பு' மற்றும் 'பெருக்கி' அவை உறுப்பினர் மாறிகள்.
பின்னர், இரண்டு மாறிகளையும் அணுக, “calProductOfTwo()” செயல்பாடு என்ற பெயரில் ஒரு செயல்பாட்டை இங்கு வரையறுக்கிறோம். இது இங்கு உறுப்பினர் செயல்பாடு மற்றும் இந்த செயல்பாட்டில் உள்ள உறுப்பினர் மாறிகளை அணுகுவோம். இதற்குக் கீழே 'திரும்ப' முக்கிய சொல்லைப் பயன்படுத்துகிறோம், மேலும் இந்த இரண்டு மாறிகளின் தயாரிப்பை வழங்கும் 'மதிப்பு * பெருக்கி' ஐ வைக்கிறோம்.
பின்னர், 'P_obj' என்ற பெயரில் 'ProductClass' இன் பொருளை உருவாக்கும் 'main()' செயல்பாட்டை நாங்கள் செயல்படுத்துகிறோம், பின்னர் நாங்கள் முன்னர் அறிவித்த உறுப்பினர் மாறிகளுக்கு மதிப்புகளை ஒதுக்குகிறோம். 'வகுப்பு' பொருளின் உதவியுடன் இந்த மாறிகளை துவக்குகிறோம். நாம் முதலில் பொருளின் பெயரையும், பின்னர் உறுப்பினர் மாறி பெயரை “p_obj.value” ஐ வைத்து “மதிப்பு” மாறிக்கு “33” ஐ ஒதுக்குகிறோம்.
பின்னர், 'பெருக்கி' மாறியை துவக்கி, இந்த மாறிக்கு '98' ஐ ஒதுக்குவோம். இப்போது, இரண்டு உறுப்பினர் மாறிகளின் தயாரிப்பைக் காட்டும் 'p_obj' வகுப்பின் பொருளுடன் 'cout' இல் உள்ள 'calProductOfTwo()' செயல்பாட்டை அழைக்கிறோம்.
குறியீடு 2:
#பெயர்வெளி std ஐப் பயன்படுத்துதல்;
வகுப்பு தயாரிப்பு வகுப்பு {
பொது:
முழு மதிப்பு;
முழு எண்ணாக பெருக்கி;
int calProductOfTwo ( ) {
திரும்ப மதிப்பு * பெருக்கி;
}
} ;
முழு எண்ணாக ( ) {
தயாரிப்பு வகுப்பு p_obj;
p_obj.value = 33 ;
p_obj.multiplier = 98 ;
கூட் << 'இரண்டு மதிப்புகளின் தயாரிப்பு = ' << p_obj.calProductOfTwo ( ) << endl;
திரும்ப 0 ;
}
வெளியீடு:
'உறுப்பினர்' மாறிகளின் மதிப்புகளின் தயாரிப்பு இங்கே காட்டப்படும். 'உறுப்பினர்' செயல்பாட்டிற்குள் 'உறுப்பினர்' மாறிகளை அணுகுவதையும், 'வகுப்பு' பொருளை உருவாக்கி, 'உறுப்பினர்' செயல்பாட்டை அழைத்த பிறகு அவற்றை துவக்குவதையும் காணலாம். இரண்டு உறுப்பினர் மாறிகளின் மதிப்புகளின் தயாரிப்பு பின்வருவனவற்றில் கொடுக்கப்பட்டுள்ளது:
எடுத்துக்காட்டு 3:
இந்த குறியீட்டில் 'சம்கிளாஸ்' இங்கே வரையறுக்கப்பட்டுள்ளது. பின்னர், “பொது” என்பதில், “s_val_1”, “s_val_2” மற்றும் “s_val_3” ஆகிய பெயர்களுடன் மூன்று உறுப்பினர் மாறிகளை அறிவிக்கிறோம், மேலும் அனைத்து மாறிகளின் தரவு வகை “int” ஆகும். பின்னர், 'உறுப்பினர்' செயல்பாடான 'calSumOfTwo()' செயல்பாட்டை வரையறுக்கிறோம், மேலும் இந்த செயல்பாட்டில் உள்ள மாறிகளை அணுகுவோம். 'calSumOfTwo()' இல், 'ரிட்டர்ன்' முக்கிய சொல்லைப் பயன்படுத்துகிறோம். இங்கே, “s_val_1 + s_val_2” ஐ வைக்கிறோம்.
இப்போது, இது இந்த இரண்டு மாறிகளின் கூட்டுத்தொகையைக் கொடுக்கிறது. இதன் கீழ், “calSumOfThree()” என்ற மற்றொரு செயல்பாட்டை வரையறுக்கிறோம். இந்தச் செயல்பாட்டில், மூன்று மாறிகளையும் அவற்றின் கூட்டுத்தொகையைக் கண்டறிந்து அவற்றின் முடிவை இங்கே தருகிறோம். பின்னர், நாம் 'முதன்மை ()' முறையை அழைக்கிறோம். இங்கே உருவாக்கப்படும் 'வகுப்பு' பொருள் 'sObj1' ஆகும்.
இதற்குப் பிறகு, 'வகுப்பு' பொருளின் உதவியுடன் மூன்று உறுப்பினர் மாறிகளையும் துவக்கி, '33', '98' மற்றும் '195' ஆகியவற்றை முறையே 's_val_1', 's_val_2' மற்றும் 's_val_3' க்கு ஒதுக்குவோம். பின்னர், 'கவுட்' இல் உள்ள 'உறுப்பினர்' செயல்பாடுகள் இரண்டையும் அழைக்கிறோம், அதில் 'calSumOfTwo()' முதல் இரண்டு மாறிகளின் கூட்டுத்தொகையைக் காட்டுகிறது மற்றும் 'calSumOfThree()' மூன்று உறுப்பினர் மாறிகளின் கூட்டுத்தொகையைக் காட்டுகிறது.
குறியீடு 3:
#பெயர்வெளி std ஐப் பயன்படுத்துதல்;
வகுப்பு SumClass {
பொது:
int s_val_1;
int s_val_2;
int s_val_3;
int calSumOfTwo ( ) {
திரும்ப s_val_1 + s_val_2;
}
int calSumOfThree ( ) {
திரும்ப s_val_1 + s_val_2 + s_val_3;
}
} ;
முழு எண்ணாக ( ) {
SumClass sObj1;
sObj1.s_val_1 = 33 ;
sObj1.s_val_2 = 98 ;
sObj1.s_val_3 = 195 ;
கூட் << 'இரண்டு மதிப்புகளின் கூட்டுத்தொகை = ' << sObj1.calSumOfTwo ( ) << endl;
கூட் << 'மூன்று மதிப்புகளின் கூட்டுத்தொகை = ' << sObj1.calSumOfThree ( ) << endl;
திரும்ப 0 ;
}
வெளியீடு:
முதல் இரண்டு உறுப்பினர் மாறிகளின் கூட்டுத்தொகை '131' ஆகும், இது முதல் 'உறுப்பினர்' செயல்பாட்டை அழைப்பதன் மூலம் இங்கு கிடைக்கும். மூன்று உறுப்பினர் மாறிகளின் கூட்டுத்தொகை “326″ ஆகும், இது நமது குறியீட்டில் உள்ள இரண்டாவது “உறுப்பினர்” செயல்பாட்டை அழைப்பதன் மூலம் கிடைக்கும்.
முடிவுரை
C++ நிரலாக்கத்தில் உள்ள 'உறுப்பினர் மாறிகள்' இந்தக் கட்டுரையில் ஆழமாக ஆராயப்பட்டுள்ளன. வகுப்பை வரையறுத்த பிறகு 'உறுப்பினர் மாறிகள்' அறிவிக்கப்படுகின்றன என்பதை நாங்கள் விளக்கினோம். இந்த மாறிகள் 'வகுப்பு' பொருளை உருவாக்கிய பிறகு குறியீட்டில் எல்லா இடங்களிலிருந்தும் அணுகக்கூடியவை. 'உறுப்பினர்' செயல்பாடுகளிலும் இந்த உறுப்பினர் மாறிகளை நாம் அணுகலாம். 'வகுப்பு' பொருளை உருவாக்கிய பிறகு இந்த மாறிகளை நாங்கள் துவக்கினோம். இங்கே, எங்கள் C++ குறியீட்டில் உள்ள “உறுப்பினர் மாறிகளை” அறிவித்து, துவக்கி, அணுகினோம்.