எடுத்துக்காட்டு 1:
வரையறுக்கப்பட்ட செயல்பாடுகளைப் பயன்படுத்துவதை எளிதாக்க, “iostream” தலைப்புக் கோப்பைச் சேர்க்கிறோம். பின்னர், எங்களிடம் 'பெயர்வெளி std' உள்ளது. இதன் கீழ், 'MyNewClass' என்ற வகுப்பை உருவாக்கி, 'பொது' கட்டமைப்பாளரைப் பயன்படுத்துகிறோம்.
“பொது” என்பதில், “myFunc” என்ற உறுப்பினர் செயல்பாட்டை உருவாக்கி, “int num” ஐ “myFunc()” இன் அளவுருவாக அறிவிக்கிறோம். இதற்குக் கீழே, நாங்கள் “கவுட்” ஐப் பயன்படுத்துகிறோம் மற்றும் இதற்குக் கீழே உள்ள மெயின்() முறையைப் பயன்படுத்துகிறோம், அதில் உறுப்பினர் செயல்பாடு சுட்டிக்காட்டியை உருவாக்குகிறோம். 'MyNewClass' வகுப்பு மற்றும் அளவுரு வகை (int) ஆகியவற்றைக் குறிப்பிடுவதன் மூலம், 'MyFuncPtr' சுட்டியை உறுப்பினர் செயல்பாடு வகைக்கு அறிவிக்கிறோம்.
இதற்குப் பிறகு, 'Class_obj' என்ற வகுப்புப் பொருளை உருவாக்கி, பின்னர் '*MyFuncPtr' சுட்டியின் உதவியுடன் உறுப்பினர் செயல்பாட்டை அழைக்கிறோம். மெம்பர் ஃபங்ஷன் பாயிண்டரை அழைக்கும் போது இதை ரெண்டர் செய்வதற்கான அளவுருவாக “10” ஐ ஒதுக்குகிறோம்.
குறியீடு 1:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
வகுப்பு MyNewClass {
பொது :
வெற்றிடமானது myFunc ( முழு எண்ணாக ஒன்றில் ) {
கூட் << 'மதிப்பு' << ஒன்றில் << endl ;
}
} ;
முழு எண்ணாக முக்கிய ( ) {
வெற்றிடமானது ( MyNewClass ::* MyFuncPtr ) ( முழு எண்ணாக ) = & MyNewClass :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
திரும்ப 0 ;
}
வெளியீடு:
உறுப்பினர் செயல்பாடு சுட்டிகள் செயல்படுவதை இது விளக்குகிறது. உறுப்பினர் செயல்பாடு சுட்டிக்காட்டி உறுப்பினர் செயல்பாடுகளை தற்போதைய நிலைமைகளுக்கு ஏற்ப மாறும் வகையில் தொடங்க பயன்படுத்தலாம்.
எடுத்துக்காட்டு 2:
'iostream' தலைப்புக் கோப்பில் வரையறுக்கப்பட்டுள்ள செயல்பாடுகளை எளிமையாகப் பயன்படுத்த, 'iostream'ஐ இங்கே சேர்க்கிறோம். 'நேம்ஸ்பேஸ் std' அடுத்ததாக வைக்கப்பட்டுள்ளது. அதன் கீழ், நாங்கள் 'சோதனை' வகுப்பை உருவாக்கி, பின்னர் 'பொது' கட்டமைப்பாளரைப் பயன்படுத்துகிறோம். 'பொது' என்பதில் 'myTestingFunc' உறுப்பினர் செயல்பாட்டை வரையறுத்து, இந்த நிகழ்வில் 'myTestingFunc()'க்கான அளவுருவாக 'int t_value' ஐ அமைக்கிறோம். 'cout' செயல்பாடு கீழே பயன்படுத்தப்படுகிறது மற்றும் முக்கிய() முறை அழைக்கப்படுகிறது. பின்னர், உறுப்பினர் செயல்பாடு சுட்டிக்காட்டி உருவாக்குகிறோம்.
'Test' வகுப்பு மற்றும் '*MyTestFuncPtr' உறுப்பினர் செயல்பாடு சுட்டிக்காட்டி ஆகியவற்றை நாங்கள் இங்கே குறிப்பிடுகிறோம். உறுப்பினர் செயல்பாடு சுட்டிக்காட்டிக்கு '&Test::myTestingFunc' ஒதுக்குகிறோம், இது 'செல்லம் (Test::*MyTestFuncPtr)(int)' என அறிவிக்கப்படுகிறது.
அடுத்து, “t_obj” கிளாஸ் ஆப்ஜெக்ட்டை உருவாக்கி, கிளாஸ் ஆப்ஜெக்ட்டை வைத்து “*MyTestFuncPtr” சுட்டியைப் பயன்படுத்தி உறுப்பினர் செயல்பாட்டை அழைக்க இதைப் பயன்படுத்துகிறோம். உறுப்பினர் செயல்பாடு சுட்டிக்காட்டியை அழைக்கும் போது இது வழங்கப்பட, அளவுருவாக “932” ஐ ஒதுக்குகிறோம்.
குறியீடு 2:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
வகுப்பு சோதனை {
பொது :
வெற்றிடமானது myTestingFunc ( முழு எண்ணாக t_மதிப்பு ) {
கூட் << 'சோதனை மதிப்பு' << t_மதிப்பு << endl ;
}
} ;
முழு எண்ணாக முக்கிய ( ) {
வெற்றிடமானது ( சோதனை ::* MyTestFuncPtr ) ( முழு எண்ணாக ) = & சோதனை :: myTestingFunc ;
சோதனை t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
திரும்ப 0 ;
}
வெளியீடு:
கொடுக்கப்பட்ட குறியீட்டின் விளைவு வழங்கப்படுகிறது. இங்கே காட்டப்பட்டுள்ளபடி 'உறுப்பினர் செயல்பாடு சுட்டிக்காட்டி' என்பதை வர்க்கப் பொருளுடன் அழைப்பதைக் காணலாம்.
எடுத்துக்காட்டு 3:
இந்தக் குறியீட்டில் நாம் உருவாக்கும் வகுப்பு “MyNewCar” ஆகும், அங்கு நாம் “பொது” கட்டமைப்பாளரைப் பயன்படுத்தி அதில் உறுப்பினர் செயல்பாட்டை உருவாக்குகிறோம், அது “startCarEngine()”. இந்தச் செயல்பாட்டில், 'cout' ஐச் சேர்க்கிறோம், இது எங்கள் குறியீட்டில் இந்த செயல்பாட்டை அழைக்கும் போது வழங்கப்படும். பின்னர், 'stopCarEngine()' என்ற மற்றொரு உறுப்பினர் செயல்பாட்டை உருவாக்கி, இந்த உறுப்பினர் செயல்பாட்டில் மீண்டும் 'cout' ஐப் பயன்படுத்துவோம்.
இதற்குப் பிறகு, நாங்கள் மெயின்() செயல்பாட்டை செயல்படுத்தி, 'MyNewCar::*carEngineFunc()' என்ற உறுப்பினர் செயல்பாடு சுட்டிக்காட்டியை அறிவிக்கிறோம். இதற்குக் கீழே, 'myCar_obj' என்ற பெயருடன் 'MyNewCar' வகுப்பு பொருளை உருவாக்குகிறோம். பின்னர், 'carEngineFunc' சுட்டிக்காட்டிக்கு 'startCarEngine' செயல்பாட்டை ஒதுக்குகிறோம். இதன் அடியில், 'carEngineFunc' சுட்டியின் உதவியுடன் பொருளின் பெயரை வைத்து இந்த செயல்பாட்டை அழைக்கிறோம்.
அடுத்து, 'stopCarEngine' செயல்பாட்டை 'carEngineFunc' சுட்டிக்காட்டிக்கு மீண்டும் ஒதுக்குகிறோம். அதற்குக் கீழே, 'carEngineFunc' குறிப்புடன் பொருளின் பெயரைக் கடந்து இந்த செயல்பாட்டை அழைக்கிறோம்.
குறியீடு 3:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
வகுப்பு MyNewCar {
பொது :
வெற்றிடமானது ஸ்டார்ட் கேர்என்ஜின் ( ) {
கூட் << 'காரின் எஞ்சின் துவங்குகிறது' << endl ;
}
வெற்றிடமானது கார்எஞ்சினை நிறுத்து ( ) {
கூட் << 'காரின் எஞ்சின் நிற்கிறது' << endl ;
}
} ;
முழு எண்ணாக முக்கிய ( ) {
வெற்றிடமானது ( MyNewCar ::* carEngineFunc ) ( ) ;
MyNewCar myCar_obj ;
carEngineFunc = & MyNewCar :: ஸ்டார்ட் கேர்என்ஜின் ;
( myCar_obj. * carEngineFunc ) ( ) ;
carEngineFunc = & MyNewCar :: கார்எஞ்சினை நிறுத்து ;
( myCar_obj. * carEngineFunc ) ( ) ;
திரும்ப 0 ;
}
வெளியீடு:
இங்கே, 'உறுப்பினர் செயல்பாடு சுட்டிக்காட்டி' வேலை காட்டப்படும். நாம் உறுப்பினர் செயல்பாடு சுட்டியை உருவாக்கி அதன் முடிவை இங்கே காண்பிப்பதைக் காணலாம்.
எடுத்துக்காட்டு 4:
தலைப்பு கோப்பு மற்றும் 'std பெயர்வெளி' ஆகியவற்றைச் சேர்த்த பிறகு, 'MyNewStudent' வகுப்பை இங்கே அறிவிக்கிறோம். 'ஸ்டூடன்ட் பாஸ்()' உறுப்பினர் செயல்பாடு என்பது நாம் இங்கு உருவாக்கும் 'MyStudentClass' வகுப்பிற்காக உருவாக்கும் உறுப்பினர் செயல்பாடுகளில் ஒன்றாகும். இந்தச் செயல்பாட்டிற்கு 'cout' ஐயும் சேர்க்கிறோம், இது எங்கள் குறியீட்டில் அழைக்கும் போது வழங்கப்படும்.
அடுத்து, 'studentFail()' உறுப்பினர் செயல்பாட்டை எழுதுகிறோம், அங்கு நாம் மீண்டும் 'cout' ஐப் பயன்படுத்துகிறோம். முக்கிய() செயல்பாடு பின்னர் அழைக்கப்படுகிறது மற்றும் '(MyNewStudent::*studentResultFunc)()' உறுப்பினர் செயல்பாடு சுட்டிக்காட்டி அறிவிக்கப்படும். அதற்குக் கீழே, 'MyNewStudent' வகுப்பிற்குச் சொந்தமான 'myStd_obj' பொருளை உருவாக்குகிறோம்.
அடுத்து, 'studentPass' செயல்பாட்டை 'studentResultFunc' சுட்டிக்காட்டிக்கு ஒதுக்குகிறோம். அதற்குக் கீழே, 'studentResultFunc' குறிப்புடன் பொருளின் பெயரைக் கடந்து இந்த செயல்பாட்டை அழைக்கிறோம். “studentFail” செயல்பாடு “studentResultFunc” சுட்டிக்கு மீண்டும் ஒதுக்கப்பட்டது. அதற்குக் கீழே, “carEngineFunc” குறிப்பு மற்றும் பொருளின் பெயரைக் கொடுத்து இந்த முறையைப் பயன்படுத்துகிறோம்.
இப்போது, இரண்டு செயல்பாடுகளும் இங்கே அழைக்கப்படுகின்றன, மேலும் இந்த செயல்பாடுகளில் நாம் சேர்த்த அறிக்கைகள் வழங்கப்படுகின்றன.
குறியீடு 4:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
வகுப்பு MyNewStudent {
பொது :
வெற்றிடமானது மாணவர் பாஸ் ( ) {
கூட் << 'மாணவர் தேர்ச்சி' << endl ;
}
வெற்றிடமானது மாணவர் தோல்வி ( ) {
கூட் << 'மாணவர் தோல்வி' << endl ;
}
} ;
முழு எண்ணாக முக்கிய ( ) {
வெற்றிடமானது ( MyNewStudent ::* studentResultFunc ) ( ) ;
MyNewStudent myStd_obj ;
studentResultFunc = & MyNewStudent :: மாணவர் பாஸ் ;
( myStd_obj. * studentResultFunc ) ( ) ;
studentResultFunc = & MyNewStudent :: மாணவர் தோல்வி ;
( myStd_obj. * studentResultFunc ) ( ) ;
திரும்ப 0 ;
}
வெளியீடு:
நாங்கள் எங்கள் குறியீட்டில் உறுப்பினர் செயல்பாடுகளை உருவாக்கினோம், பின்னர் உறுப்பினர் செயல்பாடு சுட்டிக்காட்டி. இதற்குப் பிறகு, உறுப்பினர் செயல்பாட்டை அழைத்து, முடிவை இங்கே காட்டினோம்.
எடுத்துக்காட்டு 5:
இந்த நிகழ்வில் 'மாதிரி வகுப்பு' உருவாக்கப்பட்டது. பின்னர், உறுப்பினர் செயல்பாடு சுட்டிக்காட்டி '(SampleClass::*MyFunc)()' ஆகும். இதன் அடியில், '(*MyFuncPtr)()' என்ற செயல்பாட்டு சுட்டியை உருவாக்குகிறோம். அதன் கீழே, 'ஸ்ட்ரிங்' மாறியின் 'பெயர்' மற்றும் 'MyFunc f' உறுப்பினர் செயல்பாடு சுட்டிக்காட்டி ஆகியவற்றை அறிவிக்கிறோம்.
இதற்குப் பிறகு, எங்களிடம் “பொது” கன்ஸ்ட்ரக்டர் உள்ளது, அங்கு இந்த உறுப்பினர் செயல்பாடு மாறியை வரையறுக்கிறோம். இதன் அடியில், 'myFunc_1()' மற்றும் 'myFunc_1()' என பெயரிடப்பட்ட உறுப்பினர் செயல்பாடுகளை நாங்கள் உருவாக்குகிறோம், மேலும் இந்த உறுப்பினர் செயல்பாட்டை அழைக்கும் போது காண்பிக்கப்படும் ஒவ்வொரு உறுப்பினர் செயல்பாட்டிலும் 'cout' ஐ சேர்க்கிறோம்.
பின்னர், '(இது->*f)()' உதவியுடன் இந்த உறுப்பினர் செயல்பாடு சுட்டிக்காட்டி என்று அழைக்கிறோம். பின்னர், செயல்பாடுகளை மீண்டும் வைக்கிறோம். இங்கே, நாங்கள் முன்பு சேர்த்த 'கவுட்' அறிக்கைகளை மாற்றுகிறோம். பின்னர், “main()” இப்போது செயல்படுத்தப்பட்டு உறுப்பினர் செயல்பாடு சுட்டிக்காட்டி “MyFunc f = &SampleClass::myFunc_2” என வரையறுக்கப்படுகிறது.
பின்னர், செயல்பாடு சுட்டிக்காட்டி 'MyFuncPtr fp = myFunc_1' எனவும் வரையறுக்கப்படுகிறது. இதற்குப் பிறகு, உறுப்பினர் செயல்பாடு சுட்டிக்காட்டியைப் பயன்படுத்த “(a.*f)()” என தட்டச்சு செய்கிறோம். உறுப்பினர் செயல்பாட்டைப் பயன்படுத்த 'b.func' வைக்கப்பட்டுள்ளது. பின்னர், செயல்பாடு சுட்டிக்காட்டி அழைக்க 'fp()' ஐ வைக்கிறோம்.
குறியீடு 5:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
வகுப்பு மாதிரி வகுப்பு ;
typedef வெற்றிடமானது ( மாதிரி வகுப்பு ::* MyFunc ) ( ) ;
typedef வெற்றிடமானது ( * MyFuncPtr ) ( ) ;
வகுப்பு மாதிரி வகுப்பு {
சரம் பெயர் ;
MyFunc f ;
பொது :
மாதிரி வகுப்பு ( நிலையான கரி * பெயர் )
: பெயர் ( பெயர் ) ,
f ( & மாதிரி வகுப்பு :: myFunc_1 )
{ }
வெற்றிடமானது myFunc_1 ( ) { கூட் << பெயர் << 'ஃபக்ஷன் 1ஐ இங்கு அழைத்தோம்' << endl ; }
வெற்றிடமானது myFunc_2 ( ) { கூட் << பெயர் << 'நாங்கள் இங்கே செயல்பாடு 2 ஐ அழைத்தோம்' << endl ; }
வெற்றிடமானது செயல்பாடு ( ) {
( இது ->* f ) ( ) ;
}
} ;
வெற்றிடமானது myFunc_1 ( ) { கூட் << 'முதல் செயல்பாடு' << endl ; }
வெற்றிடமானது myFunc_2 ( ) { கூட் << 'இரண்டாவது செயல்பாடு' << endl ; }
முழு எண்ணாக முக்கிய ( )
{
MyFunc f = & மாதிரி வகுப்பு :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
மாதிரி வகுப்பு ஏ ( 'முதல் -' ) , பி ( 'இரண்டாவது -' ) ;
( அ. * f ) ( ) ;
பி. செயல்பாடு ( ) ;
fp ( ) ;
}
வெளியீடு:
குறியீட்டின் விளைவு இப்போது இங்கே வழங்கப்பட்டுள்ளது, இது எங்கள் குறியீட்டில் உள்ள செயல்பாடுகளை நாங்கள் அழைத்ததைப் போலவே முடிவையும் வழங்குகிறது.
முடிவுரை
C++ இல் உள்ள “உறுப்பினர் செயல்பாட்டு சுட்டிகள்” OOP இன் சூழலில் மாறும் பிணைப்பு, நடத்தையின் இணைத்தல் மற்றும் செயல்பாட்டு அழைப்பின் நெகிழ்வான கையாளுதல் ஆகியவற்றை எளிதாக்குகிறது என்பதை நாங்கள் ஆராய்ந்தோம். 'உறுப்பினர் செயல்பாடு சுட்டிகள்' பயன்பாடு C++ கோட்பேஸ்களின் மட்டுப்படுத்தல் மற்றும் நெகிழ்வுத்தன்மையை கணிசமாக மேம்படுத்தலாம், இது பல வடிவமைப்பு மற்றும் இயக்க நேர சவால்களை எதிர்கொள்வதற்கான சக்திவாய்ந்த கருவியை வழங்குகிறது.