Esempio 1:
Includiamo il file di intestazione 'iostream' per facilitare l'utilizzo delle funzioni definite. Quindi, abbiamo il “namespace std”. Al di sotto di questo, generiamo la classe denominata 'MyNewClass' e utilizziamo il costruttore 'public'.
In 'public', creiamo la funzione membro denominata 'myFunc' e dichiariamo 'int num' come parametro di 'myFunc()'. Al di sotto di questo, utilizziamo 'cout' e invochiamo il metodo main() in cui creiamo il puntatore alla funzione membro. Dichiariamo il puntatore “MyFuncPtr” al tipo di funzione membro, specificando la classe “MyNewClass” e il tipo di parametro (int).
Successivamente creiamo l'oggetto classe denominato 'Class_obj' e quindi chiamiamo la funzione membro con l'aiuto del puntatore '*MyFuncPtr' posizionando l'oggetto classe con questo. Assegniamo '10' come parametro per renderlo quando chiamiamo il puntatore alla funzione membro.
Codice 1:
#includeutilizzando lo spazio dei nomi std ;
classe MiaNuovaClasse {
pubblico :
vuoto miaFunz ( int nessuno ) {
cout << 'Il valore è' << nessuno << fine ;
}
} ;
int principale ( ) {
vuoto ( MiaNuovaClasse ::* MyFuncPtr ) ( int ) = & MiaNuovaClasse :: miaFunz ;
MyNewClass Class_obj ;
( Classe_oggetto * MyFuncPtr ) ( 10 ) ;
ritorno 0 ;
}
Produzione:
Questo illustra il funzionamento dei puntatori alle funzioni membro. Il puntatore della funzione membro può essere utilizzato per avviare le funzioni membro in modo dinamico in base alle condizioni attuali.
Esempio 2:
Per utilizzare semplicemente le funzioni definite nel file di intestazione 'iostream', includiamo 'iostream' qui. Lo 'spazio dei nomi std' viene posizionato successivamente. Sotto di essa creiamo la classe 'Test' e quindi utilizziamo il costruttore 'pubblico'. Definiamo la funzione membro 'myTestingFunc' in 'public' e impostiamo 'int t_value' come parametro per 'myTestingFunc()' in questa istanza. Di seguito viene utilizzata la funzione 'cout' e viene chiamato il metodo main(). Quindi, creiamo il puntatore alla funzione membro.
Qui specifichiamo la classe 'Test' e il puntatore alla funzione membro '*MyTestFuncPtr'. Assegniamo '&Test::myTestingFunc' al puntatore della funzione membro dichiarato come 'void (Test::*MyTestFuncPtr)(int)'.
Successivamente, generiamo l'oggetto classe 't_obj' e lo utilizziamo per chiamare la funzione membro inserendo l'oggetto classe e utilizzando il puntatore '*MyTestFuncPtr'. Affinché questo venga presentato quando chiamiamo il puntatore alla funzione membro, assegniamo '932' come parametro.
Codice 2:
#includeutilizzando lo spazio dei nomi std ;
prova di classe {
pubblico :
vuoto myTestingFunc ( int valore_t ) {
cout << 'Il valore del test è' << valore_t << fine ;
}
} ;
int principale ( ) {
vuoto ( Test ::* MyTestFuncPtr ) ( int ) = & Test :: myTestingFunc ;
Prova t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
ritorno 0 ;
}
Produzione:
Viene visualizzato il risultato del codice specificato. Possiamo vedere che abbiamo chiamato il 'puntatore alla funzione membro' con l'oggetto classe come mostrato qui.
Esempio 3:
La classe che generiamo in questo codice è 'MyNewCar' in cui utilizziamo il costruttore 'pubblico' e creiamo al suo interno la funzione membro che è 'startCarEngine()'. In questa funzione aggiungiamo 'cout' che viene visualizzato quando chiamiamo questa funzione nel nostro codice. Quindi, creiamo un'altra funzione membro che è 'stopCarEngine()' e utilizziamo nuovamente 'cout' in questa funzione membro.
Successivamente, invochiamo la funzione main() e quindi dichiariamo il puntatore della funzione membro che è 'MyNewCar::*carEngineFunc()'. Al di sotto di questo, creiamo l'oggetto della classe 'MyNewCar' con il nome 'myCar_obj'. Quindi, assegniamo la funzione “startCarEngine” al puntatore “carEngineFunc”. Sotto chiamiamo questa funzione con l'aiuto del puntatore “carEngineFunc” inserendovi il nome dell'oggetto.
Successivamente, riassegniamo la funzione “stopCarEngine” al puntatore “carEngineFunc”. Successivamente chiamiamo questa funzione passando il nome dell'oggetto insieme al riferimento 'carEngineFunc'.
Codice 3:
#includeutilizzando lo spazio dei nomi std ;
classe MyNewCar {
pubblico :
vuoto startCarEngine ( ) {
cout << 'Il motore dell'auto si avvia' << fine ;
}
vuoto stopCarEngine ( ) {
cout << 'Il motore dell'auto si ferma' << fine ;
}
} ;
int principale ( ) {
vuoto ( La mia nuova auto ::* carEngineFunc ) ( ) ;
MyNewCar myCar_obj ;
carEngineFunc = & La mia nuova auto :: startCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
carEngineFunc = & La mia nuova auto :: stopCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
ritorno 0 ;
}
Produzione:
Qui viene visualizzato il funzionamento del “puntatore alla funzione membro”. Possiamo vedere che abbiamo creato il puntatore alla funzione membro e visualizzato il risultato qui.
Esempio 4:
Dopo aver incluso il file di intestazione e lo 'spazio dei nomi std', dichiariamo qui la classe 'MyNewStudent'. La funzione membro 'studentPass()' è una delle funzioni membro che costruiamo per la classe 'MyStudentClass' che generiamo qui. Aggiungiamo anche 'cout' a questa funzione che verrà renderizzata quando la chiameremo nel nostro codice.
Successivamente, scriviamo la funzione membro “studentFail()” dove utilizziamo ancora una volta “cout”. Viene quindi richiamata la funzione main() e viene dichiarato il puntatore alla funzione membro “(MyNewStudent::*studentResultFunc)()”. Di seguito, generiamo l'oggetto 'myStd_obj' che appartiene alla classe 'MyNewStudent'.
Successivamente, assegniamo la funzione “studentPass” al puntatore “studentResultFunc”. Successivamente chiamiamo questa funzione passando il nome dell'oggetto insieme al riferimento 'studentResultFunc'. La funzione “studentFail” viene riassegnata al puntatore “studentResultFunc”. Successivamente, invochiamo questo metodo fornendo il riferimento 'carEngineFunc' e il nome dell'oggetto.
Ora, qui vengono richiamate entrambe le funzioni e vengono renderizzate le istruzioni che abbiamo incluso in queste funzioni.
Codice 4:
#includeutilizzando lo spazio dei nomi std ;
classe Il mio nuovo studente {
pubblico :
vuoto studentePass ( ) {
cout << 'La tessera dello studente' << fine ;
}
vuoto studenteFallito ( ) {
cout << 'Lo studente fallisce' << fine ;
}
} ;
int principale ( ) {
vuoto ( Il mio nuovo studente ::* studentResultFunc ) ( ) ;
MioNuovoStudente mioStd_obj ;
studentResultFunc = & Il mio nuovo studente :: studentePass ;
( miooggetto_Std. * studentResultFunc ) ( ) ;
studentResultFunc = & Il mio nuovo studente :: studenteFallito ;
( miooggetto_Std. * studentResultFunc ) ( ) ;
ritorno 0 ;
}
Produzione:
Abbiamo creato le funzioni membro nel nostro codice e quindi il puntatore alla funzione membro. Successivamente, abbiamo chiamato la funzione membro e visualizzato qui il risultato.
Esempio 5:
In questa istanza viene creata la 'SampleClass'. Quindi, qui viene posizionato il puntatore della funzione membro che è '(SampleClass::*MyFunc)()'. Sotto questo, creiamo il puntatore alla funzione che è “(*MyFuncPtr)()”. Sotto di esso, dichiariamo il 'nome' della variabile 'string' e il puntatore alla funzione membro 'MyFunc f'.
Successivamente, abbiamo il costruttore “pubblico” in cui definiamo questa variabile della funzione membro. Al di sotto di questo, creiamo le funzioni membro denominate 'myFunc_1()' e 'myFunc_1()' e aggiungiamo anche 'cout' in ciascuna funzione membro che verrà visualizzata quando chiamiamo questa funzione membro.
Quindi, chiamiamo questo puntatore alla funzione membro con l'aiuto di '(this->*f)()'. Quindi, posizioniamo nuovamente le funzioni. Qui modifichiamo le istruzioni “cout” che abbiamo aggiunto in precedenza. Quindi, 'main()' viene ora richiamato e il puntatore alla funzione membro è definito come 'MyFunc f = &SampleClass::myFunc_2'.
Quindi, il puntatore alla funzione è anche definito come 'MyFuncPtr fp = myFunc_1'. Successivamente, digitiamo '(a.*f)()' per utilizzare il puntatore alla funzione membro. Il 'b.func' è posizionato per utilizzare la funzione membro. Quindi, inseriamo 'fp()' per chiamare il puntatore alla funzione.
Codice 5:
#includeutilizzando lo spazio dei nomi std ;
classe ClasseCampione ;
typedef vuoto ( SampleClass ::* MyFunc ) ( ) ;
typedef vuoto ( * MyFuncPtr ) ( ) ;
classe ClasseCampione {
nome della stringa ;
MyFunc f ;
pubblico :
SampleClass ( cost car * nome )
: nome ( nome ) ,
F ( & SampleClass :: miaFunzione_1 )
{ }
vuoto miaFunzione_1 ( ) { cout << nome << 'Abbiamo chiamato la funzione 1 qui' << fine ; }
vuoto myFunc_2 ( ) { cout << nome << 'Abbiamo chiamato la funzione 2 qui' << fine ; }
vuoto funz ( ) {
( Questo ->* F ) ( ) ;
}
} ;
vuoto miaFunzione_1 ( ) { cout << 'La prima funzione' << fine ; }
vuoto myFunc_2 ( ) { cout << 'La seconda funzione' << fine ; }
int principale ( )
{
MyFunc f = & SampleClass :: myFunc_2 ;
MyFuncPtr fp = miaFunzione_1 ;
Classe di esempio a ( 'Primo - ' ) , B ( 'secondo -' ) ;
( UN. * F ) ( ) ;
B. funz ( ) ;
fp ( ) ;
}
Produzione:
Il risultato del codice viene ora visualizzato qui, il che rende il risultato di conseguenza come abbiamo chiamato le funzioni nel nostro codice.
Conclusione
Abbiamo esplorato il fatto che i 'puntatori a funzioni membro' in C++ facilitano l'associazione dinamica, l'incapsulamento del comportamento e la gestione flessibile dell'invocazione di funzioni nel contesto dell'OOP. Abbiamo appreso che l'utilizzo di 'puntatori a funzioni membro' può migliorare significativamente la modularità e la flessibilità delle basi di codice C++, fornendo un potente strumento per affrontare numerose sfide di progettazione e runtime.