1. piemērs:
“iostream” ir galvenes fails, ko mēs šeit iekļaujam, jo mums ir jāizmanto šajā galvenes failā deklarētās funkcijas. 'iostream' galvenes failā ir funkcijas deklarācija. Šeit ir pievienota arī nosaukumvieta “std”. Pēc tam mēs ģenerējam klasi ar nosaukumu “FunctorClass”. Zem tā mēs ierakstām “public”, kas šeit ir publiskais konstruktors, un ievietojam funkciju “operators ()”. Pēc tam mēs ievietojam teikumu, ko vēlamies atveidot uz ekrāna paziņojumā “cout”.
Pēc tam mēs izsaucam funkciju “main()” un pēc tam izveidojam “FunctorClass” objektu ar nosaukumu “my_functor”. Šeit mēs izsaucam funkciju “my_functor()”, lai tā parādītu paziņojumu, ko pievienojām zem funkcijas “operators ()”.
1. kods:
#include
izmantojot nosaukumvieta std ;
klasē Funktorklase {
publiski :
nederīgs operators ( ) ( ) {
cout << 'Šeit sauc operāciju' ;
}
} ;
starpt galvenais ( ) {
Funktoru klase my_functor ;
mans_funkcionārs ( ) ;
atgriezties 0 ;
}
Izvade:
Rinda, ko pievienojām FunctorClass funkcijā “operators()”, tiek parādīta šeit, izmantojot funkciju “my_functor” funktiera objektu.
2. piemērs:
Šeit tiek iekļauts galvenes fails “iostream”, jo galvenes failā “iostream” ir ietverta noteikta funkciju deklarācija. Tiek ievietota arī nosaukumvieta “std”. Tālāk mēs izveidojam klasi ar nosaukumu “SquareClass”.
Zem tā mēs ierakstām “public”, kas ir publiskais konstruktors, un zem tā ievietojam datu tipa “int” funkciju “operators()”. Mēs nododam datu tipa “int” mainīgo “val” šai funkcijai “operator()”. Šī funkcija atgriež reizināšanas rezultātu, jo mēs ievietojām “val * val” funkcijā “return()” zem funkcijas “operator()”.
Tagad šeit tiek izsaukta funkcija “main()”. Pēc tam šeit tiek izveidots objekts ar klases “SquareFunctor” nosaukumu “s_functor”. Pēc tam mēs izmantojam “cout”, kas palīdz informācijas atveidē. Pēc tam mēs izsaucam objektu “my_functor()” kā funkciju, un tas atgriež reizināšanas rezultātu “5 * 5”, jo mēs pievienojām “5” kā parametru, to izsaucot.
2. kods:
#includeizmantojot nosaukumvieta std ;
klasē SquareClass {
publiski :
starpt operators ( ) ( starpt val ) {
atgriezties ( val * val ) ;
}
} ;
starpt galvenais ( ) {
SquareClass s_functor ;
cout << 'Dotās vērtības kvadrāts ir' << endl ;
cout << s_funkcija ( 5 ) ;
atgriezties 0 ;
}
Izvade:
Mēs iegūstam izvadi pēc “SqaureClass” klases objekta “my_functor” izsaukšanas, piemēram, funkcijas “my_functor()” un pēc tam nododot “5”. Mēs iegūstam “25” kā skaitļa “5” kvadrātu.
3. piemērs:
Šeit ir iekļauts galvenes fails “iostream”, jo tajā ir funkcijas deklarācija, un pēc tam tiek ieviesta nosaukumvieta “std”. Pēc tam tiek izveidota klase “ProductFunctor”. Zem tā ir ierakstīts publiskais konstruktors “public”, un zem tā ir izvietota “int” datu tipa funkcija “operators()”. Šeit mēs ignorējam šo funkciju un nododam tai divus parametrus: “int var1” un “int var2”.
Pēc tam mēs izmantojam “return” zem šī un reizinim abus mainīgos, kas atgriež abu skaitļu reizināšanas rezultātu “var1 * var2”. Šeit tiek izsaukta funkcija “main()”, un mēs ģenerējam klases objektu ar “ProductFunctor” klases nosaukumu “P_functor”. Pēc tam mēs inicializējam jaunu mainīgo ar nosaukumu “pro_result” un pēc tā izsaukšanas piešķiram objektam “P_functor” kā funkciju “P_functor()”.
Kā parametru mēs nododam “28” un “63”. Tas reizinās abas vērtības un saglabās rezultātu mainīgajā “pro_result”, ko mēs drukājam zem šī, izmantojot “cout” un nododot tajā “pro_result”.
3. kods:
#includeizmantojot nosaukumvieta std ;
klasē ProductFunctor {
publiski :
starpt operators ( ) ( starpt var1, starpt var2 ) {
atgriezties var1 * var2 ;
}
} ;
starpt galvenais ( ) {
ProductFunctor P_functor ;
starpt prod_result = P_funkcija ( 28 , 63 ) ;
cout << 'Produkts ir:' << prod_result << endl ;
atgriezties 0 ;
}
Izvade:
Produktu iegūstam pēc objekta “P_functor” izsaukšanas kā funkcijas “P_functor()” un vērtību nodošanas tam. Šo vērtību reizinājums ir “1764”.
4. piemērs:
Šajā gadījumā tiek ģenerēts “GreetingFunctorClass”. Pēc tam mēs ievietojam konstruktoru “publisks” un šajā “publiskajā” konstruktorā ignorējam funkciju “operators()”. Mēs ierakstām “Sveiki! Es šeit esmu C++ programmētājs” pēc tam, kad zem funkcijas “operator()” ir ievietots “cout”.
Tagad mēs saucam “galveno ()”. Šeit mēs izveidojam “g_functor” kā “GreetingFunctorClass” objektu un pēc tam šo objektu “g_functor” saucam par funkciju “g_functor()”. Tas dod rezultātu, ko pievienojām funkcijā “operators ()”, vienlaikus to ignorējot.
4. kods:
#includeizmantojot nosaukumvieta std ;
izmantojot nosaukumvieta std ;
klasē SveiciensFunctorClass {
publiski :
nederīgs operators ( ) ( ) {
cout << 'Sveiki! Es šeit esmu C++ programmētājs' ;
}
} ;
starpt galvenais ( ) {
SveiciensFunctorClass g_functor ;
g_funkcija ( ) ;
atgriezties 0 ;
}
Izvade:
Šeit mēs varam pamanīt, ka paziņojums, ko pievienojām, kad savā kodā ignorējām funkciju “operator()”, tiek parādīts šeit, jo mēs saucam klases objektu kā funkciju.
5. piemērs:
Šoreiz ir iekļauts “bits/stdc++.h”, jo tajā ir visas nepieciešamās funkciju deklarācijas. Pēc tam šeit tiek ievietota “std” nosaukumvieta. Šeit izveidotā klase ir “incrementFunctor” klase. Pēc tam mēs izveidojam “privātu” konstruktoru un inicializējam mainīgo “int_num” ar datu tipu “int”.
Zem šī, “publiskā” konstruktora, mēs ievietojam “incrementFunctor” un tajā ievietojam “int n1”. Pēc tam mēs ierakstām “int_num(n1)” pēc “:” ievietošanas. Pēc tam mēs ignorējam funkciju, kas ir “int” datu tipa funkcija “operator()”, un šeit deklarējam “int arrOfNum”. Pēc tam mēs izmantojam “return” un ievietojam “int_num + arrOfNum”. Tagad tas palielina “arrOfNum” vērtības, pievieno tām vērtību “int_num” un atgriež tās šeit.
Pēc “main()” izsaukšanas mēs inicializējam “arrOfNum” un šeit piešķiram dažādas veselu skaitļu vērtības. Pēc tam mainīgais “n1” tiek inicializēts, pievienojot funkciju “sizeof”, piemēram, “sizeof(arrOfNum)/sizeof(arrOfNum[0])”. Pēc tam “additionNumber” tiek inicializēts ar “3”. Tagad mēs izmantojam funkciju 'transform ()'. Šī “transform()” ir tāda pati kā “increamentFunctor” klases objekta izveide un pēc tam tā objekta izsaukšana. Pēc tam mēs izmantojam cilpu “for” un pēc tam “arrOfNum[i]”.
5. kods:
#includeizmantojot nosaukumvieta std ;
klasē incrementFunctor
{
Privāts :
starpt int_num ;
publiski :
incrementFunctor ( starpt n1 ) : int_num ( n1 ) { }
starpt operators ( ) ( starpt arrOfNum ) konst {
atgriezties int_num + arrOfNum ;
}
} ;
starpt galvenais ( )
{
starpt arrOfNum [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
starpt n1 = izmērs ( arrOfNum ) / izmērs ( arrOfNum [ 0 ] ) ;
starpt papildinājuma numurs = 3 ;
pārveidot ( arrOfNum, arrOfNum + n1, arrOfNum, incrementFunctor ( papildinājuma numurs ) ) ;
priekš ( starpt i = 0 ; i < n1 ; i ++ )
cout << arrOfNum [ i ] << ' ' ;
}
Izvade:
Šeit tiek parādīts koda rezultāts, kurā “incrementFunctor” ir “Functor”, kas tiek izmantots kā funkcija.
6. piemērs:
Šajā kodā mēs izmantojam iepriekš definētu “lielāko” funkciju. Šeit mēs kodā iekļaujam četrus dažādus galvenes failus, jo tajos ir deklarētas mūsu kodā nepieciešamās funkcijas vai metodes. Pēc tam, pievienojot “std” un pēc tam izsaucot “main()”, mēs inicializējam vektoru “myIntegerVector”. Šajā vektorā ievietojam dažas nešķirotas vērtības. Zemāk mēs izmantojam funkciju “kārtot”, lai kārtotu šīs vektoru vērtības.
Kad mēs izmantojam šo funkciju, tā sakārto vērtības augošā secībā. Bet šeit mēs izmantojam “lielāko”, kas ir C++ iepriekš definēta funkcija, kas dod kārtošanas rezultātu dilstošā veidā. Pēc tam mēs parādām sakārtotās vērtības, izmantojot cilpu “for” un pēc tam “cout”.
6. kods:
#include#include
#iekļaut
#include
izmantojot nosaukumvieta std ;
starpt galvenais ( ) {
vektors < starpt > myIntegerVector = { 13 , divdesmitviens , 19 , 44 , 32 , 42 , 9 , 6 } ;
kārtot ( myIntegerVector. sākt ( ) , myIntegerVector. beigas ( ) , lielāks < starpt > ( ) ) ;
priekš ( starpt vec_num : myIntegerVector ) {
cout << vec_num << '' ;
}
atgriezties 0 ;
}
Izvade:
Visas vektora vērtības tiek sakārtotas dilstošā veidā, izmantojot C++ iepriekš definētu funktoru, kas ir “lielākais” funkcijā, un tā definīcija ir pieejama “funkcionālajā” galvenes failā.
Secinājums
Šajā rakstā ir padziļināti izpētīts jēdziens “Functor C++”. Mēs pētījām, ka objektu var izsaukt kā funkciju, lai pārslogotu funkciju, ko sauc par “operators()”. Tas ir pazīstams kā funkcionārs. Jānodrošina publiska piekļuve, lai “operatora()” pārslodze tiktu izmantota kā paredzēts. Mēs ilustrējām dažādus piemērus, kuros savā kodā izmantojām “funktorus” un iepriekš definēto “funktoru”.