Halimbawa 1:
Ang 'iostream' ay ang header file na isinama namin dito dahil kailangan naming gamitin ang mga function na idineklara sa header file na ito. Ang 'iostream' na file ng header ay naglalaman ng isang deklarasyon ng function. Ang 'std' namespace ay idinagdag din dito. Pagkatapos, bumuo kami ng isang klase na tinatawag na 'FunctorClass'. Sa ibaba nito, itina-type namin ang 'pampubliko' na siyang pampublikong tagabuo dito at inilalagay ang function na 'operator()'. Pagkatapos, naglalagay kami ng pangungusap na gusto naming i-render sa screen sa 'cout' na pahayag.
Pagkatapos nito, tinawag namin ang function na 'main()' at pagkatapos ay likhain ang object ng 'FunctorClass' na may pangalang, 'my_functor'. Dito, tinatawag namin ang function na 'my_functor()' kaya ipinapakita nito ang statement na idinagdag namin sa ibaba ng function na 'operator()'.
Code 1:
#include
gamit namespace std ;
klase FunctorClass {
pampubliko :
walang bisa operator ( ) ( ) {
cout << 'Ang operasyon ay tinatawag dito' ;
}
} ;
int pangunahing ( ) {
FunctorClass my_functor ;
my_functor ( ) ;
bumalik 0 ;
}
Output:
Ang linya na idinagdag namin sa function na 'operator()' ng 'FunctorClass' ay ipinapakita dito sa pamamagitan ng paggamit ng 'my_functor' functor object.
Halimbawa 2:
Isinasama namin dito ang 'iostream' na header file dahil ang ilang deklarasyon ng function ay nakapaloob sa 'iostream' na header file. Ang 'std' namespace ay ipinasok din. Susunod, lumikha kami ng isang klase na pinangalanang 'SquareClass'.
Sa ibaba nito, itina-type namin ang 'pampubliko' na siyang pampublikong tagabuo at iposisyon ang 'operator()' function ng 'int' na uri ng data sa ilalim nito. Ipinapasa namin ang 'val' na variable ng 'int' na uri ng data sa function na 'operator()'. Ibinabalik ng function na ito ang resulta ng multiplikasyon habang ipinasok namin ang 'val * val' sa function na 'return()' sa ibaba ng function na 'operator()'.
Ngayon, ang function na 'main()' ay tinatawag dito. Pagkatapos, ang bagay ay nilikha dito na may pangalang 's_functor' ng klase ng 'SquareFunctor'. Pagkatapos, ginagamit namin ang 'cout' na tumutulong sa pag-render ng impormasyon. Pagkatapos nito, tinatawag namin ang object na 'my_functor()' dito tulad ng isang function at ibinabalik nito ang resulta ng multiplikasyon ng '5 * 5' habang idinagdag namin ang '5' bilang parameter habang tinatawag ito.
Code 2:
#includegamit namespace std ;
klase SquareClass {
pampubliko :
int operator ( ) ( int val ) {
bumalik ( val * val ) ;
}
} ;
int pangunahing ( ) {
SquareClass s_functor ;
cout << 'Ang parisukat ng ibinigay na halaga ay ' << endl ;
cout << s_function ( 5 ) ;
bumalik 0 ;
}
Output:
Nakukuha namin ang output pagkatapos tawagan ang 'my_functor' object ng 'SqaureClass' na klase tulad ng 'my_functor()' function at pagkatapos ay ipasa ang '5'. Nakukuha namin ang '25' bilang parisukat ng bilang na '5'.
Halimbawa 3:
Ang 'iostream' na header file ay kasama dito dahil naglalaman ito ng isang function na deklarasyon, at ang 'std' namespace ay ipinakilala pagkatapos. Ang klase ng 'ProductFunctor' ay ginawa. Ang pampublikong constructor, 'pampubliko', ay nai-type sa ibaba nito at ang 'operator()' function ng 'int' uri ng data ay nakaposisyon sa ilalim nito. In-override namin ang function na ito dito at ipinapasa ang dalawang parameter dito: 'int var1' at 'int var2'.
Pagkatapos, ginagamit namin ang 'return' sa ibaba nito at i-multiply ang parehong mga variable na nagbabalik ng resulta ng multiplikasyon ng parehong numero na 'var1 * var2'. Ang function na 'main()' ay tinawag dito at binubuo namin ang class object na may pangalang 'P_functor' ng 'ProductFunctor' class. Pagkatapos, sinisimulan namin ang isang bagong variable na may pangalang 'pro_result' at italaga ang object na 'P_functor' bilang function na 'P_functor()' pagkatapos itong tawagan.
Ipinapasa namin ang '28' at '63' bilang parameter. Paparamihin nito ang parehong mga halaga at i-save ang resulta sa variable na 'pro_result' na ipi-print namin sa ibaba nito gamit ang 'cout' at pagpasa ng 'pro_result' dito.
Code 3:
#includegamit namespace std ;
klase ProductFunctor {
pampubliko :
int operator ( ) ( int var1, int var2 ) {
bumalik var1 * var2 ;
}
} ;
int pangunahing ( ) {
ProductFunctor P_functor ;
int prod_result = P_function ( 28 , 63 ) ;
cout << 'Ang produkto ay:' << prod_result << endl ;
bumalik 0 ;
}
Output:
Nakukuha namin ang produkto pagkatapos tawagan ang object na 'P_functor' bilang function na 'P_functor()' at ipasa ang mga value dito. Ang produkto ng mga halagang iyon ay '1764'.
Halimbawa 4:
Ang 'GreetingFunctorClass' ay nabuo sa pagkakataong ito. Pagkatapos, ilalagay namin ang 'pampublikong' constructor at i-override ang 'operator()' function sa 'public' constructor na ito. Tina-type namin ang 'Hello! Isa akong C++ Programmer dito' pagkatapos ilagay ang 'cout' sa ilalim ng function na 'operator()'.
Ngayon pasulong, tinatawag namin ang 'pangunahing ()'. Ginagawa namin ang 'g_functor' dito bilang object ng 'GreetingFunctorClass' at pagkatapos ay tinatawag itong 'g_functor' object bilang 'g_functor()' function. Ibinibigay nito ang kinalabasan na idinagdag namin sa function na 'operator()' habang ino-override ito.
Code 4:
#includegamit namespace std ;
gamit namespace std ;
klase GreetingFunctorClass {
pampubliko :
walang bisa operator ( ) ( ) {
cout << 'Hello! C++ Programmer ako dito' ;
}
} ;
int pangunahing ( ) {
GreetingFunctorClass g_functor ;
g_function ( ) ;
bumalik 0 ;
}
Output:
Dito, maaari naming mapansin na ang pahayag na idinagdag namin noong na-overrode namin ang function na 'operator()' sa aming code ay ipinapakita dito habang tinatawag namin ang class object bilang isang function.
Halimbawa 5:
Ang 'bits/stdc++.h' ay kasama sa oras na ito dahil naglalaman ito ng lahat ng kinakailangang deklarasyon ng function. Pagkatapos, ang 'std' namespace ay inilalagay dito. Ang klase na ginawa namin dito ay ang 'incrementFunctor' na klase. Pagkatapos, gumawa kami ng 'pribadong' constructor at sinisimulan ang variable na 'int_num' gamit ang uri ng data na 'int'.
Sa ilalim nito, ang 'pampublikong' constructor, inilalagay namin ang 'incrementFunctor' at ipinapasa ang 'int n1' sa loob nito. Pagkatapos, i-type namin ang 'int_num(n1)' pagkatapos ilagay ang ':'. Pagkatapos, i-override namin ang function na 'operator()' function ng 'int' na uri ng data at idedeklara ang 'int arrOfNum' dito. Pagkatapos ay ginagamit namin ang 'return' at ipasok ang 'int_num + arrOfNum'. Ngayon, dinaragdagan nito ang mga halaga ng 'arrOfNum', idinaragdag ang halaga ng 'int_num' sa kanila, at ibinabalik ang mga ito dito.
Pagkatapos gamitin ang 'main()', sinisimulan namin ang 'arrOfNum' at magtalaga ng iba't ibang mga halaga ng integer dito. Pagkatapos, sinisimulan ang variable na 'n1' kung saan idinaragdag namin ang function na 'sizeof' tulad ng 'sizeof(arrOfNum)/sizeof(arrOfNum[0])'. Pagkatapos nito, ang 'additionNumber' ay pinasimulan ng '3'. Ngayon, ginagamit namin ang function na 'transform()'. Ang 'transform()' na ito ay kapareho ng paglikha ng object ng class na 'increamentFunctor' at pagkatapos ay tinawag ang object nito. Pagkatapos nito, ginagamit namin ang 'para sa' loop at pagkatapos ay 'cout' ang 'arrOfNum[i]'.
Code 5:
#includegamit namespace std ;
klase incrementFunctor
{
pribado :
int int_num ;
pampubliko :
incrementFunctor ( int n1 ) : int_num ( n1 ) { }
int operator ( ) ( int arrOfNum ) const {
bumalik int_num + arrOfNum ;
}
} ;
int pangunahing ( )
{
int arrOfNum [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
int n1 = sukat ng ( arrOfNum ) / sukat ng ( arrOfNum [ 0 ] ) ;
int numero ng karagdagan = 3 ;
ibahin ang anyo ( arrOfNum, arrOfNum + n1, arrOfNum, incrementFunctor ( numero ng karagdagan ) ) ;
para sa ( int i = 0 ; i < n1 ; i ++ )
cout << arrOfNum [ i ] << '' ;
}
Output:
Ang kinalabasan ng code ay ipinapakita dito kung saan ang 'incrementFunctor' ay ang 'Functor' na ginagamit bilang function.
Halimbawa 6:
Sa code na ito, ginagamit namin ang paunang natukoy na 'greater' functor. Dito, isinama namin ang apat na magkakaibang mga file ng header dahil kailangan namin ang mga ito sa aming code dahil ang mga function o pamamaraan na kailangan namin sa aming code ay ipinahayag sa kanila. Pagkatapos, pagkatapos idagdag ang 'std' at pagkatapos ay tawagan ang 'main()', sinisimulan namin ang 'myIntegerVector' vector. Naglalagay kami ng ilang hindi naayos na mga halaga sa vector na ito. Sa ibaba nito, inilalapat namin ang function na 'pag-uuri' upang pag-uri-uriin ang mga halaga ng vector na ito.
Kapag ginamit namin ang function na ito, inuuri nito ang mga halaga sa pataas na pagkakasunud-sunod. Ngunit ginagamit namin ang 'mas malaki' dito na kung saan ay ang paunang natukoy na function sa C++ na nagbibigay ng resulta ng pag-uuri sa isang pababang paraan. Pagkatapos nito, ipinapakita namin ang mga pinagsunod-sunod na halaga sa tulong ng 'para sa' loop at pagkatapos ay 'cout'.
Code 6:
#include#include
#include
#include
gamit namespace std ;
int pangunahing ( ) {
vector < int > myIntegerVector = { 13 , dalawampu't isa , 19 , 44 , 32 , 42 , 9 , 6 } ;
uri ( myIntegerVector. magsimula ( ) , myIntegerVector. wakas ( ) , mas malaki < int > ( ) ) ;
para sa ( int vec_num : myIntegerVector ) {
cout << vec_num << '' ;
}
bumalik 0 ;
}
Output:
Ang lahat ng mga halaga ng vector ay pinagsunod-sunod sa isang pababang paraan sa tulong ng paunang-natukoy na functor sa C++ na kung saan ay ang 'greater' functor, at ang kahulugan nito ay magagamit sa 'functional' na header file.
Konklusyon
Ang konsepto ng 'functor C++' ay malalim na ginalugad sa artikulong ito. Napag-aralan namin na ang isang bagay ay maaaring gamitin bilang isang function upang mag-overload ng isang function na tinatawag na 'operator()'. Ito ay kilala bilang isang functor. Ang pampublikong pag-access ay dapat ibigay para sa labis na karga ng 'operator()' na gagamitin ayon sa nilalayon. Naglarawan kami ng iba't ibang mga halimbawa kung saan ginamit namin ang 'functors' at ang paunang natukoy na 'functor' sa aming code.