Exemplul 1:
„iostream” este fișierul antet pe care îl includem aici, deoarece trebuie să utilizăm funcțiile care sunt declarate în acest fișier antet. Fișierul antet „iostream” conține o declarație de funcție. Aici este adăugat și spațiul de nume „std”. Apoi, generăm o clasă numită „FunctorClass”. Sub aceasta, introducem „public” care este constructorul public aici și plasăm funcția „operator()”. Apoi, plasăm o propoziție pe care vrem să o redăm pe ecran în declarația „cout”.
După aceasta, numim funcția „main()” și apoi creăm obiectul „FunctorClass” cu numele „my_functor”. Aici, numim funcția „my_functor()”, astfel încât să afișeze declarația pe care am adăugat-o sub funcția „operator()”.
Cod 1:
#include
folosind spatiu de nume std ;
clasă FunctorClass {
public :
gol operator ( ) ( ) {
cout << „Operațiunea se numește aici” ;
}
} ;
int principal ( ) {
FunctorClass my_functor ;
functorul_meu ( ) ;
întoarcere 0 ;
}
Ieșire:
Linia pe care am adăugat-o în funcția „operator()” a „FunctorClass” este afișată aici utilizând obiectul functor „my_functor”.
Exemplul 2:
Includem fișierul antet „iostream” aici, deoarece o declarație de funcție este conținută în fișierul antet „iostream”. Spațiul de nume „std” este de asemenea inserat. Apoi, creăm o clasă numită „SquareClass”.
Mai jos, introducem „public” care este constructorul public și poziționăm funcția „operator()” a tipului de date „int” sub ea. Transmitem variabila „val” a tipului de date „int” acestei funcții „operator()”. Această funcție returnează rezultatul înmulțirii pe măsură ce am inserat „val * val” în funcția „return()” sub funcția „operator()”.
Acum, funcția „main()” este numită aici. Apoi, obiectul este creat aici cu numele „s_functor” al clasei „SquareFunctor”. Apoi, folosim „cout” care ajută la redarea informațiilor. După aceasta, numim obiectul „my_functor()” aici ca o funcție și returnează rezultatul înmulțirii „5 * 5”, deoarece am adăugat „5” ca parametru în timp ce îl apelăm.
Cod 2:
#includefolosind spatiu de nume std ;
clasă SquareClass {
public :
int operator ( ) ( int val ) {
întoarcere ( val * val ) ;
}
} ;
int principal ( ) {
SquareClass s_functor ;
cout << „Pătratul valorii date este” << endl ;
cout << s_funcție ( 5 ) ;
întoarcere 0 ;
}
Ieșire:
Obținem rezultatul după ce apelăm obiectul „my_functor” al clasei „SqaureClass” precum funcția „my_functor()” și apoi trecem „5”. Obținem „25” ca pătrat al numărului „5”.
Exemplul 3:
Fișierul antet „iostream” este inclus aici deoarece conține o declarație de funcție, iar spațiul de nume „std” este introdus ulterior. Se realizează apoi clasa „ProductFunctor”. Constructorul public, „public”, este introdus sub acesta, iar funcția „operator()” a tipului de date „int” este poziționată dedesubt. Ignorăm această funcție aici și trecem doi parametri în ea: „int var1” și „int var2”.
Apoi, folosim „întoarcerea” de mai jos și înmulțim ambele variabile care returnează rezultatul înmulțirii ambelor numere „var1 * var2”. Funcția „main()” este apoi apelată aici și generăm obiectul de clasă cu numele „P_functor” al clasei „ProductFunctor”. Apoi, inițializam o nouă variabilă cu numele „pro_result” și atribuim obiectului „P_functor” ca funcție „P_functor()” după apelarea acesteia.
Trecem „28” și „63” ca parametru. Acest lucru va înmulți ambele valori și va salva rezultatul în variabila „pro_result” pe care o imprimăm sub aceasta folosind „cout” și trecând „pro_result” în ea.
Cod 3:
#includefolosind spatiu de nume std ;
clasă ProductFunctor {
public :
int operator ( ) ( int var1, int var2 ) {
întoarcere var1 * var2 ;
}
} ;
int principal ( ) {
ProductFunctor P_functor ;
int prod_result = P_funcție ( 28 , 63 ) ;
cout << 'Produsul este: ' << prod_result << endl ;
întoarcere 0 ;
}
Ieșire:
Obținem produsul după ce apelăm obiectul „P_functor” ca funcție „P_functor()” și îi transmitem valorile. Produsul acestor valori este „1764”.
Exemplul 4:
„GreetingFunctorClass” este generat în acest caz. Apoi, inserăm constructorul „public” și suprascriem funcția „operator()” în acest constructor „public”. Scriem „Bună ziua! Sunt un programator C++ aici” după ce am plasat „cout” sub funcția „operator()”.
Acum, în continuare, numim „principal()”. Creăm „g_functor” aici ca obiect al „GreetingFunctorClass” și apoi numim acest obiect „g_functor” ca funcție „g_functor()”. Acest lucru dă rezultatul pe care l-am adăugat în funcția „operator()” în timp ce o suprascriem.
Cod 4:
#includefolosind spatiu de nume std ;
folosind spatiu de nume std ;
clasă GreetingFunctorClass {
public :
gol operator ( ) ( ) {
cout << 'Bună ziua! Sunt programator C++ aici' ;
}
} ;
int principal ( ) {
GreetingFunctorClass g_functor ;
g_function ( ) ;
întoarcere 0 ;
}
Ieșire:
Aici, am putea observa că instrucțiunea pe care am adăugat-o când am înlocuit funcția „operator()” din codul nostru este afișată aici, când numim obiectul clasei ca o funcție.
Exemplul 5:
„bits/stdc++.h” este inclus de data aceasta deoarece conține toate declarațiile de funcție necesare. Apoi, spațiul de nume „std” este plasat aici. Clasa pe care o creăm aici este clasa „incrementFunctor”. Apoi, creăm un constructor „privat” și inițializam variabila „int_num” cu tipul de date „int”.
Sub acesta, constructorul „public”, plasăm „incrementFunctor” și trecem „int n1” în interiorul acestuia. Apoi, introducem „int_num(n1)” după ce plasăm „:”. Apoi, suprascriem funcția care este funcția „operator()” a tipului de date „int” și declarăm aici „int arrOfNum”. Apoi folosim „return” și inserăm „int_num + arrOfNum”. Acum, aceasta incrementează valorile „arrOfNum”, adaugă valoarea „int_num” în ele și le returnează aici.
După invocarea „main()”, inițializam „arrOfNum” și atribuim diferite valori întregi aici. Apoi, variabila „n1” este inițializată unde adăugăm funcția „sizeof” precum „sizeof(arrOfNum)/sizeof(arrOfNum[0])”. După aceasta, „additionNumber” este apoi inițializat cu „3”. Acum, folosim funcția „transform()”. Acest „transform()” este același cu crearea obiectului clasei „increamentFunctor” și apoi apelarea obiectului său. După aceasta, folosim bucla „for” și apoi „cout” „arrOfNum[i]”.
Cod 5:
#includefolosind spatiu de nume std ;
clasă incrementFunctor
{
privat :
int int_num ;
public :
incrementFunctor ( int n1 ) : int_num ( n1 ) { }
int operator ( ) ( int arrOfNum ) const {
întoarcere int_num + arrOfNum ;
}
} ;
int principal ( )
{
int arrOfNum [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
int n1 = dimensiunea ( arrOfNum ) / dimensiunea ( arrOfNum [ 0 ] ) ;
int număr adițional = 3 ;
transforma ( arrOfNum, arrOfNum + n1, arrOfNum, incrementFunctor ( număr adițional ) ) ;
pentru ( int i = 0 ; i < n1 ; i ++ )
cout << arrOfNum [ i ] << ' ' ;
}
Ieșire:
Rezultatul codului este afișat aici, în care „incrementFunctor” este „Functorul” care este utilizat ca funcție.
Exemplul 6:
În acest cod, folosim functorul „mai mare” predefinit. Aici, includem patru fișiere de antet diferite, așa cum le solicităm în codul nostru, deoarece funcțiile sau metodele de care avem nevoie în codul nostru sunt declarate în ele. Apoi, după adăugarea „std” și apoi apelarea „main()”, inițializam vectorul „myIntegerVector”. Inserăm câteva valori nesortate în acest vector. Sub aceasta, aplicăm funcția „sortare” pentru a sorta aceste valori vectoriale.
Când folosim această funcție, sortează valorile în ordine crescătoare. Dar folosim „mai mare” aici, care este funcția predefinită în C++, care dă rezultatul sortării într-o manieră descendentă. După aceasta, afișăm valorile sortate cu ajutorul buclei „for” și apoi „cout”.
Cod 6:
#include#include
#include
#include
folosind spatiu de nume std ;
int principal ( ) {
vector < int > myIntegerVector = { 13 , douăzeci și unu , 19 , 44 , 32 , 42 , 9 , 6 } ;
fel ( myIntegerVector. ÎNCEPE ( ) , myIntegerVector. Sfârşit ( ) , mai mare < int > ( ) ) ;
pentru ( int vec_num : myIntegerVector ) {
cout << vec_num << '' ;
}
întoarcere 0 ;
}
Ieșire:
Toate valorile vectorului sunt sortate descendent cu ajutorul functorului predefinit în C++ care este functorul „mai mare”, iar definiția acestuia este disponibilă în fișierul antet „funcțional”.
Concluzie
Conceptul de „functor C++” este explorat profund în acest articol. Am studiat că un obiect poate fi invocat ca funcție pentru a supraîncărca o funcție numită „operator()”. Acesta este cunoscut sub numele de functor. Accesul publicului trebuie asigurat pentru ca supraîncărcarea „operatorului()” să fie utilizat conform intenției. Am ilustrat diferite exemple în care am folosit „functorii” și „functorul” predefinit în codul nostru.