எடுத்துக்காட்டு 1:
“iostream” என்பது தலைப்புக் கோப்பாகும், ஏனெனில் இந்த தலைப்புக் கோப்பில் அறிவிக்கப்பட்டுள்ள செயல்பாடுகளை நாம் பயன்படுத்த வேண்டும். 'iostream' தலைப்பு கோப்பு ஒரு செயல்பாட்டு அறிவிப்பைக் கொண்டுள்ளது. 'std' பெயர்வெளியும் இங்கே சேர்க்கப்பட்டுள்ளது. பின்னர், 'FunctorClass' என்ற வகுப்பை உருவாக்குகிறோம். இதற்குக் கீழே, 'public' என்று டைப் செய்கிறோம், இது இங்கே பொது கட்டமைப்பாளர் மற்றும் 'operator()' செயல்பாட்டை வைக்கிறோம். பின்னர், நாம் திரையில் வழங்க விரும்பும் ஒரு வாக்கியத்தை 'கவுட்' அறிக்கையில் வைக்கிறோம்.
இதற்குப் பிறகு, 'main()' செயல்பாட்டை அழைக்கிறோம், பின்னர் 'my_functor' என்ற பெயரில் 'FunctorClass' இன் பொருளை உருவாக்குகிறோம். இங்கே, 'my_functor()' செயல்பாட்டை அழைக்கிறோம், எனவே இது 'operator()' செயல்பாட்டிற்கு கீழே நாம் சேர்த்த அறிக்கையைக் காட்டுகிறது.
குறியீடு 1:
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
வர்க்கம் ஃபங்க்டர் கிளாஸ் {
பொது :
வெற்றிடமானது இயக்குபவர் ( ) ( ) {
கூட் << 'ஆபரேஷன் இங்கே அழைக்கப்படுகிறது' ;
}
} ;
முழு எண்ணாக முக்கிய ( ) {
FunctorClass my_functor ;
என்_செயல்பாட்டு ( ) ;
திரும்ப 0 ;
}
வெளியீடு:
'FunctorClass' இன் 'ஆபரேட்டர்()' செயல்பாட்டில் நாம் சேர்த்த வரி, 'my_functor' ஃபன்க்டர் பொருளைப் பயன்படுத்தி இங்கே காட்டப்படும்.
எடுத்துக்காட்டு 2:
“iostream” தலைப்புக் கோப்பை இங்கே சேர்த்துள்ளோம், ஏனெனில் சில செயல்பாடு அறிவிப்பு “iostream” தலைப்புக் கோப்பில் உள்ளது. 'std' பெயர்வெளியும் செருகப்பட்டுள்ளது. அடுத்து, 'SquareClass' என்ற வகுப்பை உருவாக்குகிறோம்.
அதற்குக் கீழே, பொது கட்டமைப்பாளரான “பொது” என்று தட்டச்சு செய்து, அதன் கீழ் “int” தரவு வகையின் “ஆபரேட்டர்()” செயல்பாட்டை வைக்கிறோம். 'int' தரவு வகையின் 'val' மாறியை இந்த 'operator()' செயல்பாட்டிற்கு அனுப்புகிறோம். “ஆபரேட்டர்()” செயல்பாட்டிற்கு கீழே உள்ள “ரிட்டர்ன்()” செயல்பாட்டில் “val * val” ஐ செருகியதால் இந்த செயல்பாடு பெருக்கல் முடிவை வழங்குகிறது.
இப்போது, 'main()' செயல்பாடு இங்கே அழைக்கப்படுகிறது. பின்னர், 'SquareFunctor' வகுப்பின் 's_functor' என்ற பெயரில் பொருள் இங்கே உருவாக்கப்படுகிறது. பின்னர், தகவலை வழங்குவதற்கு உதவும் 'கவுட்' ஐப் பயன்படுத்துகிறோம். இதற்குப் பிறகு, “my_functor()” பொருளை இங்கே ஒரு செயல்பாடு போல அழைக்கிறோம், மேலும் அதை அழைக்கும் போது “5” ஐ அளவுருவாகச் சேர்த்ததால், “5 * 5” இன் பெருக்கல் முடிவை வழங்குகிறது.
குறியீடு 2:
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
வர்க்கம் சதுர வகுப்பு {
பொது :
முழு எண்ணாக இயக்குபவர் ( ) ( முழு எண்ணாக மதிப்பு ) {
திரும்ப ( மதிப்பு * மதிப்பு ) ;
}
} ;
முழு எண்ணாக முக்கிய ( ) {
SquareClass s_functionor ;
கூட் << 'கொடுக்கப்பட்ட மதிப்பின் சதுரம்' << endl ;
கூட் << s_செயல்பாடு ( 5 ) ;
திரும்ப 0 ;
}
வெளியீடு:
'my_functor()' செயல்பாடு போன்ற 'SqaureClass' வகுப்பின் 'my_functor' ஆப்ஜெக்ட்டை அழைத்து, பின்னர் '5'ஐ கடந்த பிறகு வெளியீட்டைப் பெறுவோம். '5' என்ற எண்ணின் வர்க்கமாக '25' கிடைக்கும்.
எடுத்துக்காட்டு 3:
“iostream” தலைப்புக் கோப்பு இங்கே சேர்க்கப்பட்டுள்ளது, ஏனெனில் அது ஒரு செயல்பாட்டு அறிவிப்பைக் கொண்டுள்ளது, மேலும் “std” பெயர்வெளி அறிமுகப்படுத்தப்பட்டது. 'ProductFunctor' வகுப்பு பின்னர் செய்யப்படுகிறது. பொது கட்டமைப்பாளர், 'பொது', அதன் கீழே தட்டச்சு செய்யப்பட்டுள்ளது மற்றும் 'int' தரவு வகையின் 'ஆபரேட்டர்()' செயல்பாடு அதன் கீழ் நிலைநிறுத்தப்பட்டுள்ளது. இந்தச் செயல்பாட்டை நாங்கள் இங்கு மேலெழுந்து, அதில் இரண்டு அளவுருக்களை அனுப்புகிறோம்: 'int var1' மற்றும் 'int var2'.
பின்னர், இதற்குக் கீழே உள்ள 'திரும்ப' பயன்படுத்தி, 'var1 * var2' என்ற இரு எண்களின் பெருக்கல் முடிவை வழங்கும் இரண்டு மாறிகளையும் பெருக்குவோம். 'main()' செயல்பாடு இங்கே அழைக்கப்படுகிறது, மேலும் 'ProductFunctor' வகுப்பின் 'P_functor' என்ற பெயரில் வகுப்பு பொருளை உருவாக்குகிறோம். பின்னர், 'pro_result' என்ற பெயரில் ஒரு புதிய மாறியை துவக்கி, 'P_functor' ஆப்ஜெக்ட்டை அழைத்த பிறகு 'P_functor()' செயல்பாடாக ஒதுக்குவோம்.
நாம் அளவுருவாக '28' மற்றும் '63' ஐ கடந்து செல்கிறோம். இது இரண்டு மதிப்புகளையும் பெருக்கி, முடிவை 'pro_result' மாறியில் சேமிக்கும், அதை நாம் கீழே 'cout' ஐப் பயன்படுத்தி அச்சிட்டு அதில் 'pro_result' ஐ அனுப்புவோம்.
குறியீடு 3:
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
வர்க்கம் தயாரிப்பு செயல்பாடு {
பொது :
முழு எண்ணாக இயக்குபவர் ( ) ( முழு எண்ணாக var1, முழு எண்ணாக var2 ) {
திரும்ப var1 * var2 ;
}
} ;
முழு எண்ணாக முக்கிய ( ) {
தயாரிப்பு செயல்பாடு P_functor ;
முழு எண்ணாக தயாரிப்பு_முடிவு = பி_செயல்பாடு ( 28 , 63 ) ;
கூட் << 'தயாரிப்பு:' << தயாரிப்பு_முடிவு << endl ;
திரும்ப 0 ;
}
வெளியீடு:
“P_functor” ஆப்ஜெக்ட்டை “P_functor()” செயல்பாடாக அழைத்து மதிப்புகளை அதற்கு அனுப்பிய பிறகு தயாரிப்பைப் பெறுகிறோம். அந்த மதிப்புகளின் தயாரிப்பு '1764' ஆகும்.
எடுத்துக்காட்டு 4:
இந்த நிகழ்வில் 'GreetingFunctorClass' உருவாக்கப்படுகிறது. பின்னர், 'பொது' கட்டமைப்பாளரைச் செருகி, இந்த 'பொது' கட்டமைப்பாளரில் 'ஆபரேட்டர்()' செயல்பாட்டை மேலெழுதுவோம். நாங்கள் 'வணக்கம்! 'ஆபரேட்டர்()' செயல்பாட்டின் கீழ் 'கவுட்' ஐ வைத்த பிறகு நான் இங்கே ஒரு சி++ புரோகிராமர்.
இப்போது நாம் 'முக்கிய()' என்று அழைக்கிறோம். இங்கே 'G_functor' ஐ 'GreetingFunctorClass' இன் பொருளாக உருவாக்கி, இந்த 'g_functor' பொருளை 'g_functor()' சார்பு என்று அழைக்கிறோம். இது “ஆபரேட்டர்()” செயல்பாட்டில் நாம் சேர்த்த விளைவை மேலெழுதும்போது அளிக்கிறது.
குறியீடு 4:
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
வர்க்கம் க்ரீட்டிங்ஃபங்க்டர் கிளாஸ் {
பொது :
வெற்றிடமானது இயக்குபவர் ( ) ( ) {
கூட் << 'ஹலோ! நான் இங்கே ஒரு C++ புரோகிராமர்' ;
}
} ;
முழு எண்ணாக முக்கிய ( ) {
க்ரீட்டிங்ஃபங்க்டர் கிளாஸ் ஜி_ஃபங்க்டர் ;
g_செயல்பாடு ( ) ;
திரும்ப 0 ;
}
வெளியீடு:
இங்கே, எங்கள் குறியீட்டில் உள்ள “ஆபரேட்டர்()” செயல்பாட்டை மீறும் போது நாம் சேர்த்த அறிக்கை, வர்க்கப் பொருளை ஒரு செயல்பாடு போல அழைக்கும்போது இங்கே காட்டப்படுவதை நாம் கவனிக்கலாம்.
எடுத்துக்காட்டு 5:
'bits/stdc++.h' இந்த முறை சேர்க்கப்பட்டுள்ளது, ஏனெனில் இது தேவையான அனைத்து செயல்பாட்டு அறிவிப்புகளையும் கொண்டுள்ளது. பின்னர், 'std' பெயர்வெளி இங்கு வைக்கப்பட்டுள்ளது. இங்கே நாம் உருவாக்கும் வகுப்பு 'incrementFunctor' வகுப்பு. பின்னர், நாங்கள் ஒரு 'தனியார்' கட்டமைப்பாளரை உருவாக்கி, 'int_num' மாறியை 'int' தரவு வகையுடன் துவக்குவோம்.
இதன் கீழ், 'பொது' கட்டமைப்பாளர், 'incrementFunctor' ஐ வைத்து அதன் உள்ளே 'int n1' ஐ அனுப்புகிறோம். பின்னர், ':' ஐ வைத்த பிறகு 'int_num(n1)' என்று தட்டச்சு செய்கிறோம். பின்னர், 'int' தரவு வகையின் 'ஆபரேட்டர்()' செயல்பாடான செயல்பாட்டை நாங்கள் மேலெழுதுகிறோம் மற்றும் இங்கே 'int arrOfNum' என்று அறிவிக்கிறோம். நாங்கள் 'திரும்ப' பயன்படுத்துகிறோம் மற்றும் 'int_num + arrOfNum' ஐ செருகுவோம். இப்போது, இது “arrOfNum” இன் மதிப்புகளை அதிகரித்து, அவற்றில் “int_num” மதிப்பைச் சேர்த்து, அவற்றை இங்கே திருப்பித் தருகிறது.
“main()” ஐ செயல்படுத்திய பிறகு, “arrOfNum” ஐ துவக்கி, வெவ்வேறு முழு எண் மதிப்புகளை இங்கு ஒதுக்குவோம். பின்னர், “sizeof(arrOfNum)/sizeof(arrOfNum[0])” போன்ற “sizeof” செயல்பாட்டைச் சேர்க்கும் இடத்தில் “n1” மாறி துவக்கப்படுகிறது. இதற்குப் பிறகு, 'கூடுதல் எண்' பின்னர் '3' உடன் துவக்கப்படும். இப்போது, நாம் 'மாற்றம்()' செயல்பாட்டைப் பயன்படுத்துகிறோம். இந்த “உருமாற்றம்()” என்பது “increammentFunctor” வகுப்பின் பொருளை உருவாக்கி அதன் பொருளை அழைப்பதற்கு சமம். இதற்குப் பிறகு, 'for' லூப்பைப் பயன்படுத்துகிறோம், பின்னர் 'arrOfNum[i]' ஐ 'கவுட்' செய்கிறோம்.
குறியீடு 5:
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
வர்க்கம் அதிகரிப்பு செயல்பாடு
{
தனிப்பட்ட :
முழு எண்ணாக int_num ;
பொது :
அதிகரிப்பு செயல்பாடு ( முழு எண்ணாக n1 ) : int_num ( n1 ) { }
முழு எண்ணாக இயக்குபவர் ( ) ( முழு எண்ணாக arrOfNum ) நிலையான {
திரும்ப int_num + arrOfNum ;
}
} ;
முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக arrOfNum [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
முழு எண்ணாக n1 = அளவு ( arrOfNum ) / அளவு ( arrOfNum [ 0 ] ) ;
முழு எண்ணாக கூட்டல் எண் = 3 ;
மாற்றம் ( arrOfNum, arrOfNum + n1, arrOfNum, incrementFunctor ( கூட்டல் எண் ) ) ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < n1 ; நான் ++ )
கூட் << arrOfNum [ நான் ] << '' ;
}
வெளியீடு:
குறியீட்டின் விளைவு இங்கே காட்டப்பட்டுள்ளது, இதில் 'incrementFunctor' என்பது 'Functor' ஆகும், இது செயல்பாடாகப் பயன்படுத்தப்படுகிறது.
எடுத்துக்காட்டு 6:
இந்தக் குறியீட்டில், முன் வரையறுக்கப்பட்ட 'பெரிய' செயல்பாட்டைப் பயன்படுத்துகிறோம். இங்கே, நான்கு வெவ்வேறு தலைப்புக் கோப்புகளை நாங்கள் சேர்க்கிறோம், ஏனெனில் அவை எங்கள் குறியீட்டில் தேவைப்படுகின்றன, ஏனெனில் எங்கள் குறியீட்டில் நமக்குத் தேவையான செயல்பாடுகள் அல்லது முறைகள் அவற்றில் அறிவிக்கப்பட்டுள்ளன. பின்னர், “std” ஐச் சேர்த்த பிறகு, “main()” ஐ அழைத்த பிறகு, “myIntegerVector” வெக்டரைத் துவக்குகிறோம். இந்த வெக்டரில் வரிசைப்படுத்தப்படாத சில மதிப்புகளைச் செருகுவோம். இதற்குக் கீழே, இந்த வெக்டார் மதிப்புகளை வரிசைப்படுத்த “வரிசைப்படுத்து” செயல்பாட்டைப் பயன்படுத்துகிறோம்.
இந்த செயல்பாட்டை நாம் பயன்படுத்தும்போது, அது மதிப்புகளை ஏறுவரிசையில் வரிசைப்படுத்துகிறது. ஆனால் C++ இல் உள்ள முன் வரையறுக்கப்பட்ட செயல்பாடான “பெரிய” என்பதை நாங்கள் இங்கு பயன்படுத்துகிறோம், இது இறங்கு முறையில் வரிசைப்படுத்துவதன் முடிவை அளிக்கிறது. இதற்குப் பிறகு, வரிசைப்படுத்தப்பட்ட மதிப்புகளை 'for' loop மற்றும் 'cout' உதவியுடன் காண்பிக்கிறோம்.
குறியீடு 6:
##அடங்கும் <அல்காரிதம்>
#
# <செயல்பாட்டு> அடங்கும்
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( ) {
திசையன் < முழு எண்ணாக > myIntegerVector = { 13 , இருபத்து ஒன்று , 19 , 44 , 32 , 42 , 9 , 6 } ;
வகைபடுத்து ( myIntegerVector. தொடங்கும் ( ) , myIntegerVector. முடிவு ( ) , பெரியது < முழு எண்ணாக > ( ) ) ;
க்கான ( முழு எண்ணாக vec_num : myIntegerVector ) {
கூட் << vec_num << '' ;
}
திரும்ப 0 ;
}
வெளியீடு:
வெக்டரின் அனைத்து மதிப்புகளும் C++ இல் உள்ள முன் வரையறுக்கப்பட்ட செயல்பாட்டின் உதவியுடன் இறங்கு முறையில் வரிசைப்படுத்தப்படுகின்றன, இது 'பெரிய' செயல்பாடு ஆகும், மேலும் அதன் வரையறை 'செயல்பாட்டு' தலைப்பு கோப்பில் கிடைக்கிறது.
முடிவுரை
இந்த கட்டுரையில் 'செயல்பாட்டு C++' என்ற கருத்து ஆழமாக ஆராயப்படுகிறது. 'ஆப்பரேட்டர்()' எனப்படும் செயல்பாட்டை ஓவர்லோட் செய்வதற்கான செயல்பாடாக ஒரு பொருளை செயல்படுத்தலாம் என்று ஆய்வு செய்தோம். இது ஒரு செயல்பாடு என்று அழைக்கப்படுகிறது. 'ஆபரேட்டர்()' இன் ஓவர்லோடிங்கிற்கு பொது அணுகல் வழங்கப்பட வேண்டும். எங்கள் குறியீட்டில் உள்ள 'பங்க்டர்கள்' மற்றும் முன் வரையறுக்கப்பட்ட 'பங்க்டர்' ஆகியவற்றைப் பயன்படுத்திய வெவ்வேறு எடுத்துக்காட்டுகளை நாங்கள் விளக்கினோம்.