Näide 1:
Lisame 'iostream' päisefaili, et hõlbustada määratletud funktsioonide kasutamist. Seejärel on meil 'nimeruum std'. Selle all genereerime klassi nimega 'MyNewClass' ja kasutame 'avalikku' konstruktorit.
Avalikkuses loome liikmefunktsiooni nimega 'myFunc' ja deklareerime 'myFunc()' parameetriks 'int num'. Selle all kasutame 'cout' ja käivitame selle all meetodi main(), mille abil loome liikmefunktsiooni osuti. Deklareerime 'MyFuncPtr' kursori liikmefunktsiooni tüübile, täpsustades klassi 'MyNewClass' ja parameetri tüübi (int).
Pärast seda loome klassiobjekti nimega 'Class_obj' ja seejärel kutsume '*MyFuncPtr' osuti abil liikmefunktsiooni, asetades klassiobjekti selle juurde. Liikmefunktsiooni osuti kutsumisel määrame selle renderdamiseks parameetriks '10'.
Kood 1:
#includekasutades nimeruumi std ;
klass MinuUusKlass {
avalik :
tühine myFunc ( int ühel ) {
cout << 'Väärtus on' << ühel << endl ;
}
} ;
int peamine ( ) {
tühine ( Minu UusKlass ::* MyFuncPtr ) ( int ) = & Minu UusKlass :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
tagasi 0 ;
}
Väljund:
See illustreerib liikmefunktsiooni osutite tööd. Liikmefunktsiooni kursorit saab kasutada liikmefunktsioonide dünaamiliseks käivitamiseks vastavalt praegustele tingimustele.
Näide 2:
Funktsioonide kasutamiseks, mis on määratletud päisefailis 'iostream' lihtne, lisame siia 'iostream'. Järgmisena asetatakse nimeruum std. Selle alla loome klassi 'Test' ja seejärel kasutame 'avalikku' konstruktorit. Määratleme funktsiooni myTestingFunc liigefunktsiooni 'public' ja määrame sel juhul 'myTestingFunc()' parameetriks 'int t_value'. Allpool kasutatakse funktsiooni “cout” ja kutsutakse välja main() meetod. Seejärel loome liikmefunktsiooni osuti.
Määrame siin klassi 'Test' ja '*MyTestFuncPtr' liigefunktsiooni osuti. Määrame liikmefunktsiooni osutile '&Test::myTestingFunc', mis on deklareeritud kui 'kehtetu (Test::*MyTestFuncPtr)(int)'.
Järgmisena genereerime klassiobjekti 't_obj' ja kasutame seda liikmefunktsiooni kutsumiseks, pannes klassiobjekti ja kasutades kursorit '*MyTestFuncPtr'. Selle esitamiseks liikmefunktsiooni osuti kutsumisel määrame parameetriks '932'.
Kood 2:
#includekasutades nimeruumi std ;
klassi Test {
avalik :
tühine myTestingFunc ( int t_väärtus ) {
cout << 'Testimise väärtus on' << t_väärtus << endl ;
}
} ;
int peamine ( ) {
tühine ( Test ::* MyTestFuncPtr ) ( int ) = & Test :: myTestingFunc ;
Test t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
tagasi 0 ;
}
Väljund:
Antud koodi tulemus renderdatakse. Näeme, et kutsusime klassiobjektiga 'liikmefunktsiooni osuti', nagu siin näidatud.
Näide 3:
Klass, mille selles koodis genereerime, on 'MyNewCar', kus kasutame 'avalikku' konstruktorit ja loome selles liikmefunktsiooni, mis on 'startCarEngine()'. Sellesse funktsiooni lisame 'cout', mis renderdab, kui kutsume seda funktsiooni oma koodis. Seejärel loome teise liikmefunktsiooni, mis on 'stopCarEngine()' ja kasutame selles liikmefunktsioonis uuesti 'cout'.
Pärast seda käivitame funktsiooni main() ja seejärel kuulutame liikmefunktsiooni osuti, milleks on 'MyNewCar::*carEngineFunc()'. Selle alla loome 'MyNewCar' klassi objekti nimega 'myCar_obj'. Seejärel määrame kursorile „carEngineFunc” funktsiooni „startCarEngine”. Selle all kutsume seda funktsiooni 'carEngineFunc' kursori abil, asetades sellele objekti nime.
Järgmisena määrame funktsiooni 'stopCarEngine' uuesti kursorile 'carEngineFunc'. Sellest allpool kutsume seda funktsiooni, edastades objekti nime koos viitega “carEngineFunc”.
Kood 3:
#includekasutades nimeruumi std ;
klassi MyNewCar {
avalik :
tühine startCarEngine ( ) {
cout << 'Auto mootor käivitub' << endl ;
}
tühine stopCarEngine ( ) {
cout << 'Auto mootor seiskub' << endl ;
}
} ;
int peamine ( ) {
tühine ( Minu Uus Auto ::* autoMootori funktsioon ) ( ) ;
MinuUusAuto myCar_obj ;
autoMootori funktsioon = & Minu Uus Auto :: startCarEngine ;
( myCar_obj. * autoMootori funktsioon ) ( ) ;
autoMootori funktsioon = & Minu Uus Auto :: stopCarEngine ;
( myCar_obj. * autoMootori funktsioon ) ( ) ;
tagasi 0 ;
}
Väljund:
Siin kuvatakse liikmefunktsiooni osuti töö. Näeme, et lõime liikmefunktsiooni osuti ja kuvasime tulemuse siin.
Näide 4:
Pärast päisefaili ja 'std-nimeruumi' lisamist kuulutame siin välja klassi 'MyNewStudent'. Liikfunktsioon ” studentPass()” on üks liigefunktsioonidest, mille loome siin genereeritava klassi „MyStudentClass” jaoks. Lisame sellele funktsioonile ka sõna 'cout', mis renderdatakse, kui seda oma koodis kutsume.
Järgmisena kirjutame liikmefunktsiooni “studentFail()”, kus kasutame veel kord sõna “cout”. Seejärel kutsutakse välja funktsioon main() ja deklareeritakse liigefunktsiooni osuti '(MyNewStudent::*studentResultFunc)()'. Selle all genereerime objekti 'myStd_obj', mis kuulub klassi 'MyNewStudent'.
Järgmisena määrame kursorile 'studentResultFunc' funktsiooni 'studentPass'. Sellest allpool kutsume seda funktsiooni, edastades objekti nime koos viitega 'studentResultFunc'. Funktsioon „studentFail” määratakse uuesti kursorile „ studentResultFunc”. Selle all kasutame seda meetodit, andes viite 'carEngineFunc' ja objekti nime.
Nüüd kutsutakse siin mõlemad funktsioonid ja renderdatakse nendesse funktsioonidesse lisatud avaldused.
Kood 4:
#includekasutades nimeruumi std ;
klassi MinuNewStudent {
avalik :
tühine üliõpilaspass ( ) {
cout << 'Üliõpilaspass' << endl ;
}
tühine õpilane Fail ( ) {
cout << 'Õpilane ebaõnnestub' << endl ;
}
} ;
int peamine ( ) {
tühine ( Minu uusõpilane ::* õpilaneResultFunc ) ( ) ;
MyNewStudent myStd_obj ;
õpilaneResultFunc = & Minu uusõpilane :: üliõpilaspass ;
( myStd_obj. * õpilaneResultFunc ) ( ) ;
õpilaneResultFunc = & Minu uusõpilane :: õpilane Fail ;
( myStd_obj. * õpilaneResultFunc ) ( ) ;
tagasi 0 ;
}
Väljund:
Lõime oma koodis liikmefunktsioonid ja seejärel liikmefunktsiooni osuti. Pärast seda kutsusime liikmefunktsiooni ja kuvasime tulemuse siin.
Näide 5:
Sel juhul luuakse 'SampleClass'. Seejärel asetatakse siia liikmefunktsiooni osuti, mis on '(SampleClass::*MyFunc)()'. Selle alla loome funktsioonikursori, mis on '(*MyFuncPtr)()'. Selle all deklareerime muutuja 'string' nime ja liikmefunktsiooni 'MyFunc f' osuti.
Pärast seda on meil avalik konstruktor, kus määratleme selle liikmefunktsiooni muutuja. Selle all loome liikmefunktsioonid nimega 'myFunc_1()' ja 'myFunc_1()' ning lisame igasse liikmefunktsiooni ka 'cout', mis kuvatakse selle liikmefunktsiooni kutsumisel.
Seejärel kutsume selle liikmefunktsiooni osuti '(this->*f)()' abil. Seejärel asetame funktsioonid uuesti. Siin muudame varem lisatud lauseid 'cout'. Seejärel kutsutakse välja 'main()' ja liikmefunktsiooni osuti määratletakse kui 'MyFunc f = &SampleClass::myFunc_2'.
Seejärel määratletakse funktsioonikursor ka kui 'MyFuncPtr fp = myFunc_1'. Pärast seda tippime liikmefunktsiooni osuti kasutamiseks “(a.*f)()”. 'b.func' on paigutatud liikmefunktsiooni kasutamiseks. Seejärel asetame funktsiooni osuti kutsumiseks 'fp()'.
Kood 5:
#includekasutades nimeruumi std ;
klass Näidisklass ;
typedef tühine ( Näidisklass ::* MyFunc ) ( ) ;
typedef tühine ( * MyFuncPtr ) ( ) ;
klass Näidisklass {
stringi nimi ;
MyFunc f ;
avalik :
Näidisklass ( konst char * nimi )
: nimi ( nimi ) ,
f ( & Näidisklass :: myFunc_1 )
{ }
tühine myFunc_1 ( ) { cout << nimi << 'Me kutsusime siia fuction 1' << endl ; }
tühine myFunc_2 ( ) { cout << nimi << 'Me kutsusime siin funktsiooni 2' << endl ; }
tühine func ( ) {
( see ->* f ) ( ) ;
}
} ;
tühine myFunc_1 ( ) { cout << 'Esimene funktsioon' << endl ; }
tühine myFunc_2 ( ) { cout << 'Teine funktsioon' << endl ; }
int peamine ( )
{
MyFunc f = & Näidisklass :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
Näidisklass a ( 'esimene -' ) , b ( 'teine -' ) ;
( a. * f ) ( ) ;
b. func ( ) ;
fp ( ) ;
}
Väljund:
Siin renderdatakse nüüd koodi tulemus, mis renderdab tulemuse vastavalt nii, nagu me oma koodi funktsioone nimetasime.
Järeldus
Uurisime, et C++ 'liikmefunktsiooni osutid' hõlbustavad dünaamilist sidumist, käitumise kapseldamist ja funktsiooni kutsumise paindlikku käsitlemist OOP kontekstis. Saime teada, et 'liikmefunktsiooni osutite' kasutamine võib oluliselt parandada C++ koodibaaside modulaarsust ja paindlikkust, pakkudes võimsat tööriista arvukate disaini- ja käitusaegsete väljakutsete lahendamiseks.