Eksempel 1:
'iostream' er header-filen, som vi inkluderer her, fordi vi skal bruge de funktioner, der er erklæret i denne header-fil. 'iostream'-headerfilen indeholder en funktionserklæring. 'std'-navnerummet tilføjes også her. Derefter genererer vi en klasse kaldet 'FunctorClass'. Under dette skriver vi 'public', som er den offentlige konstruktør her og placerer funktionen 'operator()'. Derefter placerer vi en sætning, som vi ønsker at gengive på skærmen i 'cout'-sætningen.
Herefter kalder vi funktionen 'main()' og opretter derefter objektet for 'FunctorClass' med navnet 'my_functor'. Her kalder vi 'my_functor()'-funktionen, så den viser sætningen, som vi tilføjede under 'operator()'-funktionen.
Kode 1:
#include
ved brug af navneområde std ;
klasse FunctorClass {
offentlig :
ugyldig operatør ( ) ( ) {
cout << 'Operationen kaldes her' ;
}
} ;
int vigtigste ( ) {
FunctorClass my_functor ;
min_funktionær ( ) ;
Vend tilbage 0 ;
}
Produktion:
Linjen, som vi tilføjede i 'operator()'-funktionen i 'FunctorClass' vises her ved at bruge 'my_functor'-funktionsobjektet.
Eksempel 2:
Vi inkluderer 'iostream'-headerfilen her, fordi en funktionserklæring er indeholdt i 'iostream'-headerfilen. 'std'-navneområdet er også indsat. Dernæst opretter vi en klasse ved navn 'SquareClass'.
Herunder skriver vi 'public', som er den offentlige konstruktør og placerer 'operator()'-funktionen for 'int'-datatypen under den. Vi sender 'val'-variablen af 'int'-datatypen til denne 'operator()'-funktion. Denne funktion returnerer multiplikationsresultatet, da vi indsatte 'val * val' i 'return()'-funktionen under 'operator()'-funktionen.
Nu kaldes 'main()'-funktionen her. Derefter oprettes objektet her med navnet 's_functor' af klassen 'SquareFunctor'. Derefter bruger vi 'cout', som hjælper med at gengive informationen. Efter dette kalder vi 'my_functor()'-objektet her som en funktion, og det returnerer multiplikationsresultatet af '5 * 5', da vi tilføjede '5' som parameter, mens vi kaldte det.
Kode 2:
#includeved brug af navneområde std ;
klasse SquareClass {
offentlig :
int operatør ( ) ( int val ) {
Vend tilbage ( val * val ) ;
}
} ;
int vigtigste ( ) {
SquareClass s_functor ;
cout << 'Kvadratet af den givne værdi er' << endl ;
cout << s_funktion ( 5 ) ;
Vend tilbage 0 ;
}
Produktion:
Vi får outputtet efter at have kaldt 'my_functor'-objektet i 'SqaureClass'-klassen som 'my_functor()'-funktionen og derefter passeret '5'. Vi får '25' som kvadratet af tallet '5'.
Eksempel 3:
'iostream'-headerfilen er inkluderet her, fordi den indeholder en funktionserklæring, og 'std'-navnerummet introduceres efterfølgende. Derefter laves klassen 'ProductFunctor'. Den offentlige konstruktør, 'public', er skrevet under den, og 'operator()'-funktionen for 'int'-datatypen er placeret under den. Vi tilsidesætter denne funktion her og sender to parametre ind i den: 'int var1' og 'int var2'.
Derefter bruger vi 'afkastet' under dette og multiplicerer begge variable, som returnerer multiplikationsresultatet af begge tal 'var1 * var2'. Funktionen 'main()' kaldes så her, og vi genererer klasseobjektet med navnet 'P_functor' af klassen 'ProductFunctor'. Derefter initialiserer vi en ny variabel med navnet 'pro_result' og tildeler 'P_functor'-objektet som funktionen 'P_functor()' efter at have kaldt det.
Vi sender '28' og '63' som parameter. Dette vil gange begge værdier og gemme resultatet i 'pro_result'-variablen, som vi udskriver under denne ved at bruge 'cout' og sende 'pro_result' i den.
Kode 3:
#includeved brug af navneområde std ;
klasse Produktfunktion {
offentlig :
int operatør ( ) ( int var1, int var2 ) {
Vend tilbage var1 * var2 ;
}
} ;
int vigtigste ( ) {
ProductFunctor P_functor ;
int prod_result = P_funktion ( 28 , 63 ) ;
cout << 'Produktet er:' << prod_result << endl ;
Vend tilbage 0 ;
}
Produktion:
Vi får produktet efter at have kaldt 'P_functor'-objektet som 'P_functor()'-funktionen og videregivet værdierne til det. Produktet af disse værdier er '1764'.
Eksempel 4:
'GreetingFunctorClass' genereres i dette tilfælde. Derefter indsætter vi den 'offentlige' konstruktør og tilsidesætter 'operator()'-funktionen i denne 'offentlige' konstruktør. Vi skriver 'Hej! Jeg er en C++ programmør her' efter at have placeret 'cout' under 'operator()'-funktionen.
Nu og frem kalder vi 'main()'. Vi opretter 'g_functor' her som objektet for 'GreetingFunctorClass' og kalder derefter dette 'g_functor'-objekt som 'g_functor()'-funktionen. Dette giver det resultat, som vi tilføjede i funktionen 'operator()', mens vi tilsidesatte det.
Kode 4:
#includeved brug af navneområde std ;
ved brug af navneområde std ;
klasse Hilsen FunctorClass {
offentlig :
ugyldig operatør ( ) ( ) {
cout << 'Hej! Jeg er en C++ programmør her' ;
}
} ;
int vigtigste ( ) {
GreetingFunctorClass g_functor ;
g_funktion ( ) ;
Vend tilbage 0 ;
}
Produktion:
Her kan vi måske bemærke, at sætningen, som vi tilføjede, da vi overrodede 'operator()'-funktionen i vores kode, vises her, da vi kalder klasseobjektet som en funktion.
Eksempel 5:
'bits/stdc++.h' er inkluderet denne gang, da den indeholder alle nødvendige funktionserklæringer. Derefter placeres 'std'-navnerummet her. Klassen, som vi opretter her, er klassen 'incrementFunctor'. Derefter opretter vi en 'privat' konstruktør og initialiserer 'int_num' variablen med 'int' datatypen.
Under denne, den 'offentlige' konstruktør, placerer vi 'incrementFunctor' og sender 'int n1' inde i den. Derefter skriver vi 'int_num(n1)' efter at have placeret ':'. Derefter tilsidesætter vi funktionen, som er 'operator()'-funktionen af 'int'-datatypen og erklærer 'int arrOfNum' her. Vi bruger derefter 'retur' og indsætter 'int_num + arrOfNum'. Nu øger dette værdierne af 'arrOfNum', tilføjer 'int_num' værdien til dem og returnerer dem her.
Efter at have påkaldt 'main()', initialiserer vi 'arrOfNum' og tildeler forskellige heltalsværdier her. Derefter initialiseres 'n1'-variablen, hvor vi tilføjer 'sizeof'-funktionen som 'sizeof(arrOfNum)/sizeof(arrOfNum[0])'. Herefter initialiseres 'additionNumber' med '3'. Nu bruger vi funktionen 'transform()'. Denne 'transform()' er det samme som at oprette objektet i klassen 'increamentFunctor' og derefter kalde dets objekt. Efter dette bruger vi 'for'-løkken og 'cout' derefter 'arrOfNum[i]'.
Kode 5:
#includeved brug af navneområde std ;
klasse incrementFunctor
{
privat :
int int_num ;
offentlig :
incrementFunctor ( int n1 ) : int_num ( n1 ) { }
int operatør ( ) ( int arrOfNum ) konst {
Vend tilbage int_num + arrOfNum ;
}
} ;
int vigtigste ( )
{
int arrOfNum [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
int n1 = størrelse på ( arrOfNum ) / størrelse på ( arrOfNum [ 0 ] ) ;
int tillægsnummer = 3 ;
transformere ( arrOfNum, arrOfNum + n1, arrOfNum, incrementFunctor ( tillægsnummer ) ) ;
til ( int jeg = 0 ; jeg < n1 ; jeg ++ )
cout << arrOfNum [ jeg ] << ' ' ;
}
Produktion:
Resultatet af koden vises her, hvor 'incrementFunctor' er den 'Functor', der bruges som funktion.
Eksempel 6:
I denne kode bruger vi den foruddefinerede 'større' funktion. Her inkluderer vi fire forskellige header-filer, som vi kræver dem i vores kode, fordi de funktioner eller metoder, vi har brug for i vores kode, er erklæret i dem. Derefter, efter at have tilføjet 'std' og derefter kaldet 'main()', initialiserer vi 'myIntegerVector'-vektoren. Vi indsætter nogle usorterede værdier i denne vektor. Herunder anvender vi 'sort'-funktionen til at sortere disse vektorværdier.
Når vi bruger denne funktion, sorterer den værdierne i stigende rækkefølge. Men vi bruger 'større' her, som er den foruddefinerede funktion i C++, som giver resultatet af sortering på en faldende måde. Herefter viser vi de sorterede værdier ved hjælp af 'for' loop og derefter 'cout'.
Kode 6:
#include#include
#inkluder
#include
ved brug af navneområde std ;
int vigtigste ( ) {
vektor < int > myIntegerVector = { 13 , enogtyve , 19 , 44 , 32 , 42 , 9 , 6 } ;
sortere ( myIntegerVector. begynde ( ) , myIntegerVector. ende ( ) , større < int > ( ) ) ;
til ( int vec_num : myIntegerVector ) {
cout << vec_num << '' ;
}
Vend tilbage 0 ;
}
Produktion:
Alle vektorens værdier sorteres faldende ved hjælp af den foruddefinerede funktor i C++, som er den 'større' funktion, og dens definition er tilgængelig i den 'funktionelle' header-fil.
Konklusion
Begrebet 'functor C++' er dybt udforsket i denne artikel. Vi undersøgte, at et objekt kan fremkaldes som en funktion til at overbelaste en funktion kaldet 'operator()'. Dette er kendt som en funktor. Offentlig adgang skal sikres, for at overbelastningen af 'operatøren()' kan udnyttes efter hensigten. Vi illustrerede forskellige eksempler, hvor vi brugte 'funktionerne' og den foruddefinerede 'funktioner' i vores kode.