Exemple 1:
Le « iostream » est le fichier d'en-tête que nous incluons ici car nous devons utiliser les fonctions déclarées dans ce fichier d'en-tête. Le fichier d'en-tête « iostream » contient une déclaration de fonction. L'espace de noms « std » est également ajouté ici. Ensuite, nous générons une classe appelée « FunctorClass ». En dessous, nous tapons ici « public » qui est le constructeur public et plaçons la fonction « operator() ». Ensuite, nous plaçons une phrase que nous voulons restituer à l'écran dans l'instruction « cout ».
Après cela, nous appelons la fonction « main() » puis créons l'objet de « FunctorClass » avec le nom « my_functor ». Ici, nous appelons la fonction « my_functor() » afin qu'elle affiche l'instruction que nous avons ajoutée sous la fonction « Operator() ».
Codage 1 :
#include
en utilisant espace de noms norme ;
classe Classe de foncteurs {
publique :
vide opérateur ( ) ( ) {
cout << 'L'Opération s'appelle ici' ;
}
} ;
int principal ( ) {
FunctorClass mon_functor ;
mon_fonctionneur ( ) ;
retour 0 ;
}
Sortir:
La ligne que nous avons ajoutée dans la fonction « Operator() » de « FunctorClass » est affichée ici en utilisant l'objet foncteur « my_functor ».
Exemple 2 :
Nous incluons ici le fichier d'en-tête « iostream », car certaines déclarations de fonction sont contenues dans le fichier d'en-tête « iostream ». L'espace de noms « std » est également inséré. Ensuite, nous créons une classe nommée « SquareClass ».
En dessous, nous tapons « public » qui est le constructeur public et plaçons la fonction « operator() » du type de données « int » en dessous. Nous passons la variable « val » du type de données « int » à cette fonction « Operator() ». Cette fonction renvoie le résultat de la multiplication car nous avons inséré « val * val » dans la fonction « return() » sous la fonction « Operator() ».
Maintenant, la fonction « main() » est appelée ici. Ensuite, l'objet est créé ici avec le nom « s_functor » de la classe « SquareFunctor ». Ensuite, nous utilisons le « cout » qui aide à restituer les informations. Après cela, nous appelons ici l'objet « my_functor() » comme une fonction et il renvoie le résultat de la multiplication de « 5 * 5 » car nous avons ajouté « 5 » comme paramètre lors de son appel.
Code 2 :
#includeen utilisant espace de noms norme ;
classe Classe Carrée {
publique :
int opérateur ( ) ( int Val ) {
retour ( Val * Val ) ;
}
} ;
int principal ( ) {
S_foncteur SquareClass ;
cout << 'Le carré de la valeur donnée est ' << fin ;
cout << s_fonction ( 5 ) ;
retour 0 ;
}
Sortir:
Nous obtenons le résultat après avoir appelé l'objet « my_functor » de la classe « SquareClass » comme la fonction « my_functor() » puis passé « 5 ». Nous obtenons « 25 » comme carré du nombre « 5 ».
Exemple 3 :
Le fichier d'en-tête « iostream » est inclus ici car il contient une déclaration de fonction, et l'espace de noms « std » est introduit ensuite. La classe « ProductFunctor » est ensuite créée. Le constructeur public, « public », est tapé en dessous et la fonction « operator() » du type de données « int » est positionnée en dessous. Nous remplaçons cette fonction ici et lui passons deux paramètres : « int var1 » et « int var2 ».
Ensuite, nous utilisons le « retour » en dessous et multiplions les deux variables qui renvoient le résultat de la multiplication des deux nombres « var1 * var2 ». La fonction « main() » est alors appelée ici et nous générons l'objet classe avec le nom « P_functor » de la classe « ProductFunctor ». Ensuite, nous initialisons une nouvelle variable avec le nom « pro_result » et attribuons l'objet « P_functor » comme fonction « P_functor() » après l'avoir appelé.
Nous passons « 28 » et « 63 » comme paramètres. Cela multipliera les deux valeurs et enregistrera le résultat dans la variable « pro_result » que nous imprimons en dessous en utilisant le « cout » et en y passant « pro_result ».
Code 3 :
#includeen utilisant espace de noms norme ;
classe FonctionFoncteurProduit {
publique :
int opérateur ( ) ( int var1, int var2 ) {
retour var1 * var2 ;
}
} ;
int principal ( ) {
ProductFunctor P_functor ;
int résultat_prod = Fonction P_ ( 28 , 63 ) ;
cout << 'Le produit est : ' << résultat_prod << fin ;
retour 0 ;
}
Sortir:
Nous obtenons le produit après avoir appelé l'objet « P_functor » en tant que fonction « P_functor() » et lui avoir transmis les valeurs. Le produit de ces valeurs est « 1764 ».
Exemple 4 :
Le « GreetingFunctorClass » est généré dans cette instance. Ensuite, nous insérons le constructeur « public » et remplaçons la fonction « Operator() » dans ce constructeur « public ». On tape « Bonjour ! Je suis un programmeur C++ ici » après avoir placé le « cout » sous la fonction « Operator() ».
À partir de maintenant, nous appelons le « main() ». Nous créons ici le « g_functor » en tant qu'objet de « GreetingFunctorClass », puis appelons cet objet « g_functor » comme la fonction « g_functor() ». Cela donne le résultat que nous avons ajouté dans la fonction « Operator() » en le remplaçant.
Code 4 :
#includeen utilisant espace de noms norme ;
en utilisant espace de noms norme ;
classe SalutationFunctorClass {
publique :
vide opérateur ( ) ( ) {
cout << 'Bonjour ! Je suis ici programmeur C++' ;
}
} ;
int principal ( ) {
GreetingFunctorClass g_functor ;
g_fonction ( ) ;
retour 0 ;
}
Sortir:
Ici, nous pourrions remarquer que l'instruction que nous avons ajoutée lorsque nous avons remplacé la fonction «operator()» dans notre code est affichée ici lorsque nous appelons l'objet de classe comme une fonction.
Exemple 5 :
Le « bits/stdc++.h » est inclus cette fois car il contient toutes les déclarations de fonction nécessaires. Ensuite, l'espace de noms « std » est placé ici. La classe que nous créons ici est la classe « incrementFunctor ». Ensuite, nous créons un constructeur « privé » et initialisons la variable « int_num » avec le type de données « int ».
En dessous, le constructeur « public », nous plaçons le « incrementFunctor » et passons « int n1 » à l'intérieur. Ensuite, on tape « int_num(n1) » après avoir placé le « : ». Ensuite, nous remplaçons la fonction qui est la fonction « Operator() » du type de données « int » et déclarons ici « int arrOfNum ». Nous utilisons ensuite le « return » et insérons « int_num + arrOfNum ». Maintenant, cela incrémente les valeurs de « arrOfNum », y ajoute la valeur « int_num » et les renvoie ici.
Après avoir invoqué le « main() », nous initialisons le « arrOfNum » et attribuons ici différentes valeurs entières. Ensuite, la variable « n1 » est initialisée où nous ajoutons la fonction « sizeof » comme « sizeof(arrOfNum)/sizeof(arrOfNum[0]) ». Après cela, le « additionNumber » est alors initialisé avec « 3 ». Maintenant, nous utilisons la fonction « transform() ». Ce « transform() » revient à créer l’objet de la classe « increamentFunctor » puis à appeler son objet. Après cela, nous utilisons la boucle « for » puis « cout » le « arrOfNum[i] ».
Code 5 :
#includeen utilisant espace de noms norme ;
classe incrémentFoncteur
{
privé :
int numéro_int ;
publique :
incrémentFoncteur ( int n1 ) : numéro_int ( n1 ) { }
int opérateur ( ) ( int arrOfNum ) const {
retour numéro_int + arrOfNum ;
}
} ;
int principal ( )
{
int arrOfNum [ ] = { 6 , 3 , 2 , 1 , 9 , 0 , 8 } ;
int n1 = taille de ( arrOfNum ) / taille de ( arrOfNum [ 0 ] ) ;
int numéro d'addition = 3 ;
transformer ( arrOfNum, arrOfNum + n1, arrOfNum, incrémentFunctor ( numéro d'addition ) ) ;
pour ( int je = 0 ; je < n1 ; je ++ )
cout << arrOfNum [ je ] << ' ' ;
}
Sortir:
Le résultat du code est affiché ici dans lequel «incrementFunctor» est le «Functor» utilisé comme fonction.
Exemple 6 :
Dans ce code, nous utilisons le foncteur « supérieur » prédéfini. Ici, nous incluons quatre fichiers d'en-tête différents car nous en avons besoin dans notre code car les fonctions ou méthodes dont nous avons besoin dans notre code y sont déclarées. Ensuite, après avoir ajouté « std » puis appelé « main() », nous initialisons le vecteur « myIntegerVector ». Nous insérons des valeurs non triées dans ce vecteur. En dessous, nous appliquons la fonction « trier » pour trier ces valeurs vectorielles.
Lorsque nous utilisons cette fonction, elle trie les valeurs par ordre croissant. Mais nous utilisons ici le « plus grand » qui est la fonction prédéfinie en C++ qui donne le résultat du tri de manière décroissante. Après cela, nous affichons les valeurs triées à l'aide de la boucle « for » puis « cout ».
Code 6 :
#include#include
#include
#include
en utilisant espace de noms norme ;
int principal ( ) {
vecteur < int > monVecteurEntier = { 13 , vingt-et-un , 19 , 44 , 32 , 42 , 9 , 6 } ;
trier ( monVecteurEntier. commencer ( ) , monIntegerVector. fin ( ) , plus grand < int > ( ) ) ;
pour ( int vec_num : monVecteurEntier ) {
cout << vec_num << '' ;
}
retour 0 ;
}
Sortir:
Toutes les valeurs du vecteur sont triées de manière décroissante à l'aide du foncteur prédéfini en C++ qui est le foncteur « supérieur », et sa définition est disponible dans le fichier d'en-tête « fonctionnel ».
Conclusion
Le concept de « foncteur C++ » est exploré en profondeur dans cet article. Nous avons étudié qu'un objet peut être invoqué en tant que fonction pour surcharger une fonction appelée 'operator()'. C'est ce qu'on appelle un foncteur. L'accès public doit être fourni pour que la surcharge de « operator() » soit utilisée comme prévu. Nous avons illustré différents exemples dans lesquels nous avons utilisé les « foncteurs » et le « foncteur » prédéfini dans notre code.