Exemple 1:
Nous incluons le fichier d'en-tête « iostream » pour faciliter l'utilisation des fonctions définies. Ensuite, nous avons le « namespace std ». En dessous, nous générons la classe nommée « MyNewClass » et utilisons le constructeur « public ».
Dans « public », nous créons la fonction membre nommée « myFunc » et déclarons « int num » comme paramètre de « myFunc() ». En dessous, nous utilisons le « cout » et invoquons la méthode main() en dessous dans laquelle nous créons le pointeur de fonction membre. Nous déclarons le pointeur « MyFuncPtr » vers le type de fonction membre, en spécifiant la classe « MyNewClass » et le type de paramètre (int).
Après cela, nous créons l'objet de classe nommé « Class_obj », puis appelons la fonction membre à l'aide du pointeur « *MyFuncPtr » en plaçant l'objet de classe avec celui-ci. Nous attribuons « 10 » comme paramètre pour restituer ceci lorsque nous appelons le pointeur de fonction membre.
Codage 1 :
#includeen utilisant l'espace de noms std ;
classe MaNouvelleClasse {
publique :
vide maFonction ( int sur une ) {
cout << 'La valeur est' << sur une << fin ;
}
} ;
int principal ( ) {
vide ( MaNouvelleClasse ::* MonFuncPtr ) ( int ) = & MaNouvelleClasse :: maFonction ;
MaNouvelleClasse Class_obj ;
( Classe_obj. * MonFuncPtr ) ( dix ) ;
retour 0 ;
}
Sortir:
Ceci illustre le fonctionnement des pointeurs de fonctions membres. Le pointeur de fonction membre peut être utilisé pour lancer les fonctions membres de manière dynamique en fonction des conditions actuelles.
Exemple 2 :
Pour utiliser simplement les fonctions définies dans le fichier d'en-tête « iostream », nous incluons « iostream » ici. L''espace de noms std' est placé ensuite. En dessous, nous créons la classe « Test » puis utilisons le constructeur « public ». Nous définissons la fonction membre « myTestingFunc » dans « public » et définissons « int t_value » comme paramètre pour « myTestingFunc() » dans ce cas. La fonction « cout » est utilisée ci-dessous et la méthode main() est appelée. Ensuite, nous créons le pointeur de fonction membre.
Nous spécifions ici la classe « Test » et le pointeur de fonction membre « *MyTestFuncPtr ». Nous attribuons « &Test::myTestingFunc » au pointeur de fonction membre qui est déclaré comme « void (Test::*MyTestFuncPtr)(int) ».
Ensuite, nous générons l'objet de classe « t_obj » et l'utilisons pour appeler la fonction membre en plaçant l'objet de classe et en utilisant le pointeur « *MyTestFuncPtr ». Pour que cela soit présenté lorsque nous appelons le pointeur de fonction membre, nous attribuons « 932 » comme paramètre.
Code 2 :
#includeen utilisant l'espace de noms std ;
Test de classe {
publique :
vide monTestingFunc ( int valeur_t ) {
cout << 'La valeur du test est' << valeur_t << fin ;
}
} ;
int principal ( ) {
vide ( Test ::* MonTestFuncPtr ) ( int ) = & Test :: monTestingFunc ;
Testez t_obj ;
( t_obj. * MonTestFuncPtr ) ( 932 ) ;
retour 0 ;
}
Sortir:
Le résultat du code donné est rendu. Nous pouvons voir que nous avons appelé le « pointeur de fonction membre » avec l'objet de classe comme indiqué ici.
Exemple 3 :
La classe que nous générons dans ce code est « MyNewCar » où nous utilisons le constructeur « public » et y créons la fonction membre qui est « startCarEngine() ». Dans cette fonction, nous ajoutons « cout » qui s'affiche lorsque nous appelons cette fonction dans notre code. Ensuite, nous créons une autre fonction membre qui est « stopCarEngine() » et utilisons à nouveau « cout » dans cette fonction membre.
Après cela, nous invoquons la fonction main() puis déclarons le pointeur de fonction membre qui est « MyNewCar::*carEngineFunc() ». En dessous, nous créons l'objet de classe « MyNewCar » avec le nom « myCar_obj ». Ensuite, nous attribuons la fonction « startCarEngine » au pointeur « carEngineFunc ». En dessous, nous appelons cette fonction à l'aide du pointeur « carEngineFunc » en y plaçant le nom de l'objet.
Ensuite, nous réaffectons la fonction « stopCarEngine » au pointeur « carEngineFunc ». En dessous, nous appelons cette fonction en passant le nom de l'objet avec la référence « carEngineFunc ».
Code 3 :
#includeen utilisant l'espace de noms std ;
classe MaNouvelleVoiture {
publique :
vide démarrerCarEngine ( ) {
cout << 'Le moteur de la voiture démarre' << fin ;
}
vide arrêterCarEngine ( ) {
cout << 'Le moteur de la voiture s'arrête' << fin ;
}
} ;
int principal ( ) {
vide ( Ma nouvelle voiture ::* carEngineFunc ) ( ) ;
MaNouvelleVoiture maVoiture_obj ;
carEngineFunc = & Ma nouvelle voiture :: démarrerCarEngine ;
( maVoiture_obj. * carEngineFunc ) ( ) ;
carEngineFunc = & Ma nouvelle voiture :: arrêterCarEngine ;
( maVoiture_obj. * carEngineFunc ) ( ) ;
retour 0 ;
}
Sortir:
Ici, le fonctionnement du « pointeur de fonction membre » est affiché. Nous pouvons voir que nous avons créé le pointeur de fonction membre et affiché le résultat ici.
Exemple 4 :
Après avoir inclus le fichier d'en-tête et le « espace de noms std », nous déclarons ici la classe « MyNewStudent ». La fonction membre « studentPass() » est l'une des fonctions membres que nous construisons pour la classe « MyStudentClass » que nous générons ici. Nous ajoutons également « cout » à cette fonction qui sera rendue lorsque nous l'appellerons dans notre code.
Ensuite, nous écrivons la fonction membre « studentFail() » où nous utilisons à nouveau « cout ». La fonction main() est ensuite appelée et le pointeur de fonction membre « (MyNewStudent::*studentResultFunc)() » est déclaré. En dessous, nous générons l'objet « myStd_obj » qui appartient à la classe « MyNewStudent ».
Ensuite, nous attribuons la fonction « studentPass » au pointeur « studentResultFunc ». En dessous, nous appelons cette fonction en passant le nom de l'objet avec la référence « studentResultFunc ». La fonction « studentFail » est réaffectée au pointeur « studentResultFunc ». En dessous, nous invoquons cette méthode en donnant la référence « carEngineFunc » et le nom de l'objet.
Maintenant, les deux fonctions sont appelées ici et les instructions que nous avons incluses dans ces fonctions sont rendues.
Code 4 :
#includeen utilisant l'espace de noms std ;
classe MonNouvelÉtudiant {
publique :
vide StudentPass ( ) {
cout << 'Le pass étudiant' << fin ;
}
vide étudiantÉchec ( ) {
cout << 'L'élève échoue' << fin ;
}
} ;
int principal ( ) {
vide ( Mon nouvel étudiant ::* studentResultFunc ) ( ) ;
MonNouvelÉtudiant monStd_obj ;
studentResultFunc = & Mon nouvel étudiant :: StudentPass ;
( monStd_obj. * studentResultFunc ) ( ) ;
studentResultFunc = & Mon nouvel étudiant :: étudiantÉchec ;
( monStd_obj. * studentResultFunc ) ( ) ;
retour 0 ;
}
Sortir:
Nous avons créé les fonctions membres dans notre code, puis le pointeur de fonction membre. Après cela, nous avons appelé la fonction membre et affiché le résultat ici.
Exemple 5 :
Le « SampleClass » est créé dans ce cas. Ensuite, le pointeur de fonction membre est placé ici et est « (SampleClass::*MyFunc)() ». En dessous, nous créons le pointeur de fonction qui est « (*MyFuncPtr)() ». En dessous, nous déclarons le « nom » de la variable « string » ainsi que le pointeur de fonction membre « MyFunc f ».
Après cela, nous avons le constructeur « public » où nous définissons cette variable de fonction membre. En dessous, nous créons les fonctions membres nommées « myFunc_1() » et « myFunc_1() » et ajoutons également « cout » dans chaque fonction membre qui s'affichera lorsque nous appellerons cette fonction membre.
Ensuite, nous appelons ce pointeur de fonction membre à l’aide de « (this->*f)() ». Ensuite, nous replaçons les fonctions. Ici, nous modifions les instructions « cout » que nous avons ajoutées précédemment. Ensuite, « main() » est maintenant invoqué et le pointeur de fonction membre est défini comme « MyFunc f = &SampleClass::myFunc_2 ».
Ensuite, le pointeur de fonction est également défini comme « MyFuncPtr fp = myFunc_1 ». Après cela, nous tapons « (a.*f)() » pour utiliser le pointeur de fonction membre. Le « b.func » est placé pour utiliser la fonction membre. Ensuite, nous plaçons « fp() » pour appeler le pointeur de fonction.
Code 5 :
#includeen utilisant l'espace de noms std ;
classe SampleClass ;
typedef vide ( Classe d'échantillon ::* MaFonction ) ( ) ;
typedef vide ( * MonFuncPtr ) ( ) ;
classe SampleClass {
nom de chaîne ;
MyFunc f ;
publique :
Classe d'échantillon ( const carboniser * nom )
: nom ( nom ) ,
F ( & Classe d'échantillon :: maFunc_1 )
{ }
vide maFunc_1 ( ) { cout << nom << 'Nous avons appelé la fonction 1 ici' << fin ; }
vide maFunc_2 ( ) { cout << nom << 'Nous avons appelé ici la fonction 2' << fin ; }
vide fonction ( ) {
( ce ->* F ) ( ) ;
}
} ;
vide maFunc_1 ( ) { cout << 'La première fonction' << fin ; }
vide maFunc_2 ( ) { cout << 'La deuxième fonction' << fin ; }
int principal ( )
{
MyFunc f = & Classe d'échantillon :: maFunc_2 ;
MyFuncPtr fp = maFunc_1 ;
Exemple de classe a ( 'd'abord - ' ) , b ( 'deuxième - ' ) ;
( un. * F ) ( ) ;
b. fonction ( ) ;
fp ( ) ;
}
Sortir:
Le résultat du code est maintenant rendu ici, ce qui rend le résultat conformément à la manière dont nous avons appelé les fonctions dans notre code.
Conclusion
Nous avons exploré le fait que les « pointeurs de fonctions membres » en C++ facilitent la liaison dynamique, l'encapsulation du comportement et la gestion flexible de l'invocation de fonctions dans le contexte de la POO. Nous avons appris que l'utilisation de « pointeurs de fonctions membres » peut améliorer considérablement la modularité et la flexibilité des bases de code C++, fournissant ainsi un outil puissant pour relever de nombreux défis de conception et d'exécution.