Esempio 1:
'iostream' è il file di intestazione che includiamo qui perché dobbiamo utilizzare le funzioni dichiarate in questo file di intestazione. Il file di intestazione 'iostream' contiene una dichiarazione di funzione. Qui viene aggiunto anche lo spazio dei nomi 'std'. Quindi, generiamo una classe chiamata 'FunctorClass'. Sotto questo, digitiamo 'public' che è il costruttore pubblico qui e inseriamo la funzione 'operator()'. Quindi, inseriamo una frase che vogliamo visualizzare sullo schermo nell'istruzione 'cout'.
Successivamente, chiamiamo la funzione “main()” e quindi creiamo l'oggetto “FunctorClass” con il nome “my_functor”. Qui chiamiamo la funzione “my_functor()” in modo che visualizzi l'istruzione che abbiamo aggiunto sotto la funzione “operator()”.
Codice 1:
#include
utilizzando spazio dei nomi standard ;
classe FuntorClass {
pubblico :
vuoto operatore ( ) ( ) {
cout << 'L'operazione si chiama qui' ;
}
} ;
int principale ( ) {
FunctorClass mio_funtore ;
mio_funtore ( ) ;
ritorno 0 ;
}
Produzione:
La riga che abbiamo aggiunto nella funzione “operator()” di “FunctorClass” viene visualizzata qui utilizzando l'oggetto funtore “my_functor”.
Esempio 2:
Includiamo qui il file di intestazione 'iostream' perché alcune dichiarazioni di funzioni sono contenute nel file di intestazione 'iostream'. Viene inserito anche lo spazio dei nomi “std”. Successivamente, creiamo una classe denominata 'SquareClass'.
Sotto digitiamo 'public' che è il costruttore pubblico e posizioniamo la funzione 'operator()' del tipo di dati 'int' sotto di esso. Passiamo la variabile “val” del tipo di dati “int” a questa funzione “operator()”. Questa funzione restituisce il risultato della moltiplicazione inserendo 'val * val' nella funzione 'return()' sotto la funzione 'operator()'.
Ora, la funzione “main()” viene chiamata qui. Quindi l'oggetto viene creato qui con il nome “s_functor” della classe “SquareFunctor”. Quindi, utilizziamo il 'cout' che aiuta a rendere le informazioni. Successivamente, chiamiamo l'oggetto 'my_functor()' come una funzione e restituisce il risultato della moltiplicazione di '5 * 5' poiché abbiamo aggiunto '5' come parametro durante la chiamata.
Codice 2:
#includeutilizzando spazio dei nomi standard ;
classe SquareClass {
pubblico :
int operatore ( ) ( int val ) {
ritorno ( val * val ) ;
}
} ;
int principale ( ) {
SquareClass s_funtore ;
cout << 'Il quadrato del valore dato è ' << fine ;
cout << s_funzione ( 5 ) ;
ritorno 0 ;
}
Produzione:
Otteniamo l'output dopo aver chiamato l'oggetto 'my_functor' della classe 'SqaureClass' come la funzione 'my_functor()' e quindi passando '5'. Otteniamo “25” come quadrato del numero “5”.
Esempio 3:
Il file di intestazione 'iostream' è incluso qui perché contiene una dichiarazione di funzione e lo spazio dei nomi 'std' viene introdotto successivamente. Viene quindi creata la classe 'ProductFunctor'. Il costruttore pubblico, “public”, viene digitato sotto di esso e la funzione “operator()” del tipo di dati “int” è posizionata sotto di esso. Qui sovrascriviamo questa funzione e le passiamo due parametri: 'int var1' e 'int var2'.
Quindi, utilizziamo il 'ritorno' sotto questo e moltiplichiamo entrambe le variabili che restituiscono il risultato della moltiplicazione di entrambi i numeri 'var1 * var2'. Qui viene quindi richiamata la funzione “main()” e generiamo l'oggetto classe con il nome “P_functor” della classe “ProductFunctor”. Quindi, inizializziamo una nuova variabile con il nome “pro_result” e assegniamo l'oggetto “P_functor” come funzione “P_functor()” dopo averlo chiamato.
Passiamo “28” e “63” come parametro. Questo moltiplicherà entrambi i valori e salverà il risultato nella variabile 'pro_result' che stampiamo sotto usando 'cout' e passando 'pro_result' al suo interno.
Codice 3:
#includeutilizzando spazio dei nomi standard ;
classe ProductFunctor {
pubblico :
int operatore ( ) ( int var1, int var2 ) {
ritorno var1 * var2 ;
}
} ;
int principale ( ) {
ProductFunctor P_funtore ;
int risultato_prod = Funzione_P ( 28 , 63 ) ;
cout << 'Il prodotto è: ' << risultato_prod << fine ;
ritorno 0 ;
}
Produzione:
Otteniamo il prodotto dopo aver chiamato l'oggetto “P_functor” come funzione “P_functor()” e avergli passato i valori. Il prodotto di questi valori è “1764”.
Esempio 4:
In questa istanza viene generata la 'GreetingFunctorClass'. Quindi, inseriamo il costruttore “pubblico” e sovrascriviamo la funzione “operator()” in questo costruttore “pubblico”. Digitiamo “Ciao! Sono un programmatore C++ qui' dopo aver inserito 'cout' sotto la funzione 'operator()'.
Da ora in poi chiameremo “main()”. Creiamo qui il 'g_functor' come oggetto della 'GreetingFunctorClass' e quindi chiamiamo questo oggetto 'g_functor' come funzione 'g_functor()'. Questo dà il risultato che abbiamo aggiunto nella funzione “operator()” sovrascrivendola.
Codice 4:
#includeutilizzando spazio dei nomi standard ;
utilizzando spazio dei nomi standard ;
classe GreetingFunctorClass {
pubblico :
vuoto operatore ( ) ( ) {
cout << 'Ciao! Sono un programmatore C++ qui' ;
}
} ;
int principale ( ) {
GreetingFunctorClass g_functor ;
g_funzione ( ) ;
ritorno 0 ;
}
Produzione:
Qui, potremmo notare che l'istruzione che abbiamo aggiunto quando abbiamo sovrascritto la funzione 'operator()' nel nostro codice viene visualizzata qui mentre chiamiamo l'oggetto classe come una funzione.
Esempio 5:
Questa volta è incluso 'bits/stdc++.h' poiché contiene tutte le dichiarazioni di funzione necessarie. Quindi, lo spazio dei nomi 'std' viene posizionato qui. La classe che creiamo qui è la classe “incrementFunctor”. Quindi, creiamo un costruttore “privato” e inizializziamo la variabile “int_num” con il tipo di dati “int”.
Sotto questo, il costruttore “pubblico”, posizioniamo “incrementFunctor” e passiamo “int n1” al suo interno. Quindi, digitiamo 'int_num(n1)' dopo aver inserito ':'. Quindi, sovrascriviamo la funzione che è la funzione “operator()” del tipo di dati “int” e dichiariamo qui “int arrOfNum”. Utilizziamo quindi il tasto “return” e inseriamo “int_num + arrOfNum”. Ora, questo incrementa i valori di 'arrOfNum', aggiunge loro il valore 'int_num' e li restituisce qui.
Dopo aver invocato 'main()', inizializziamo 'arrOfNum' e assegniamo qui diversi valori interi. Quindi, la variabile “n1” viene inizializzata dove aggiungiamo la funzione “sizeof” come “sizeof(arrOfNum)/sizeof(arrOfNum[0])”. Successivamente, “additionNumber” viene inizializzato con “3”. Ora utilizziamo la funzione “transform()”. Questo 'transform()' equivale a creare l'oggetto della classe 'increamentFunctor' e quindi a chiamarne l'oggetto. Successivamente, utilizziamo il ciclo 'for' e quindi 'cout' 'arrOfNum[i]'.
Codice 5:
#includeutilizzando spazio dei nomi standard ;
classe incrementoFuntore
{
privato :
int int_num ;
pubblico :
incrementoFuntore ( int n1 ) : int_num ( n1 ) { }
int operatore ( ) ( int arrOfNum ) cost {
ritorno int_num + arrOfNum ;
}
} ;
int principale ( )
{
int arrOfNum [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
int n1 = taglia di ( arrOfNum ) / taglia di ( arrOfNum [ 0 ] ) ;
int numero di addizione = 3 ;
trasformare ( arrOfNum, arrOfNum + n1, arrOfNum, incrementoFuntore ( numero di addizione ) ) ;
per ( int io = 0 ; io < n1 ; io ++ )
cout << arrOfNum [ io ] << ' ' ;
}
Produzione:
Qui viene mostrato il risultato del codice in cui 'incrementFunctor' è il 'Functor' utilizzato come funzione.
Esempio 6:
In questo codice utilizziamo il funtore “maggiore” predefinito. Qui includiamo quattro diversi file header poiché li richiediamo nel nostro codice perché le funzioni o i metodi di cui abbiamo bisogno nel nostro codice sono dichiarati in essi. Quindi, dopo aver aggiunto 'std' e aver chiamato 'main()', inizializziamo il vettore 'myIntegerVector'. Inseriamo alcuni valori non ordinati in questo vettore. Al di sotto di questo, applichiamo la funzione 'sort' per ordinare questi valori vettoriali.
Quando utilizziamo questa funzione, ordina i valori in ordine crescente. Ma qui utilizziamo il 'maggiore', che è la funzione predefinita in C++ che fornisce il risultato dell'ordinamento in modo discendente. Successivamente visualizziamo i valori ordinati con l'aiuto del ciclo 'for' e quindi 'cout'.
Codice 6:
#include#include
#include
#include
utilizzando spazio dei nomi standard ;
int principale ( ) {
vettore < int > mioVettoreIntero = { 13 , ventuno , 19 , 44 , 32 , 42 , 9 , 6 } ;
ordinare ( mioVettoreIntero. inizio ( ) , mioVettoreIntero. FINE ( ) , maggiore < int > ( ) ) ;
per ( int vec_num : mioVettoreIntero ) {
cout << vec_num << '' ;
}
ritorno 0 ;
}
Produzione:
Tutti i valori del vettore vengono ordinati in modo decrescente con l'ausilio del funtore predefinito in C++ che è il funtore “maggiore” e la sua definizione è disponibile nel file header “funzionale”.
Conclusione
Il concetto di 'funtore C++' viene esplorato in modo approfondito in questo articolo. Abbiamo studiato che un oggetto può essere invocato come funzione per sovraccaricare una funzione chiamata 'operator()'. Questo è noto come funtore. È necessario fornire l'accesso pubblico affinché l'overload di 'operator()' possa essere utilizzato come previsto. Abbiamo illustrato diversi esempi in cui abbiamo utilizzato i “funtori” e il “funtore” predefinito nel nostro codice.