Esimerkki 1:
Sisällytämme 'iostream'-otsikkotiedoston, jotta määritettyjä toimintoja on helppo käyttää. Sitten meillä on 'nimiavaruus std'. Tämän alapuolelle luomme luokan nimeltä 'MyNewClass' ja käytämme 'julkista' konstruktoria.
'Julkisessa' luomme jäsenfunktion nimeltä 'myFunc' ja määritämme 'int num' 'myFunc()'-parametriksi. Tämän alapuolella käytämme 'cout' ja kutsumme tämän alla main()-metodin, jossa luomme jäsenfunktion osoittimen. Ilmoitamme 'MyFuncPtr'-osoittimen jäsenfunktion tyypille määrittämällä 'MyNewClass'-luokan ja parametrin tyypin (int).
Tämän jälkeen luomme luokkaobjektin nimeltä “Class_obj” ja kutsumme sitten jäsenfunktiota “*MyFuncPtr”-osoittimen avulla asettamalla luokkaobjektin tähän. Määritämme '10' parametriksi tämän esittämiseksi, kun kutsumme jäsenfunktion osoitinta.
Koodi 1:
#includekäyttäen nimiavaruutta std ;
luokka MyNewClass {
julkinen :
mitätön myFunc ( int yhdellä ) {
cout << 'Arvo on' << yhdellä << endl ;
}
} ;
int pää ( ) {
mitätön ( Oma Uusiluokka ::* MyFuncPtr ) ( int ) = & Oma Uusiluokka :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
palata 0 ;
}
Lähtö:
Tämä havainnollistaa jäsenfunktioosoittimien toimintaa. Jäsenfunktion osoitinta voidaan käyttää jäsenfunktioiden käynnistämiseen dynaamisesti nykyisten olosuhteiden mukaan.
Esimerkki 2:
Jos haluat käyttää 'iostream'-otsikkotiedostossa määriteltyjä toimintoja, sisällytämme tähän 'iostream'. 'namespace std' sijoitetaan seuraavaksi. Sen alle luomme 'Testi'-luokan ja käytämme sitten 'julkista' konstruktoria. Määritämme 'myTestingFunc' -jäsenfunktion 'public'-kenttään ja asetamme 'int t_value' 'myTestingFunc()'-parametriksi tässä tapauksessa. 'cout'-funktiota käytetään alla ja main() -menetelmää kutsutaan. Sitten luomme jäsenfunktion osoittimen.
Määritämme tässä 'Test'-luokan ja '*MyTestFuncPtr' -jäsenfunktioosoittimen. Määritämme '&Test::myTestingFunc' jäsenfunktion osoittimelle, joka on ilmoitettu 'void (Test::*MyTestFuncPtr)(int)'.
Seuraavaksi luomme 't_obj'-luokan objektin ja käytämme tätä kutsumaan jäsenfunktiota asettamalla luokkaobjektin ja käyttämällä '*MyTestFuncPtr' -osoitinta. Jotta tämä näytetään, kun kutsumme jäsenfunktion osoitinta, määritämme parametriksi '932'.
Koodi 2:
#includekäyttäen nimiavaruutta std ;
luokan koe {
julkinen :
mitätön myTestingFunc ( int t_arvo ) {
cout << 'Testausarvo on' << t_arvo << endl ;
}
} ;
int pää ( ) {
mitätön ( Testata ::* MyTestFuncPtr ) ( int ) = & Testata :: myTestingFunc ;
Testaa t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
palata 0 ;
}
Lähtö:
Annetun koodin tulos hahmonnetaan. Voimme nähdä, että kutsuimme 'jäsenfunktion osoitinta' luokkaobjektin kanssa, kuten tässä on esitetty.
Esimerkki 3:
Luokka, jonka luomme tässä koodissa, on 'MyNewCar', jossa hyödynnämme 'julkista' konstruktoria ja luomme siihen jäsenfunktion, joka on 'startCarEngine()'. Tässä funktiossa lisäämme 'cout', joka hahmontuu, kun kutsumme tätä funktiota koodissamme. Sitten luomme toisen jäsenfunktion, joka on 'stopCarEngine()' ja käytämme 'cout' uudelleen tässä jäsenfunktiossa.
Tämän jälkeen kutsumme main()-funktion ja julistamme sitten jäsenfunktion osoittimen, joka on 'MyNewCar::*carEngineFunc()'. Tämän alle luomme 'MyNewCar'-luokan objektin, jonka nimi on 'myCar_obj'. Sitten määritämme 'startCarEngine'-toiminnon 'carEngineFunc'-osoittimelle. Tämän alapuolella kutsumme tätä toimintoa 'carEngineFunc'-osoittimen avulla asettamalla objektin nimen siihen.
Seuraavaksi määritämme 'stopCarEngine'-toiminnon uudelleen 'carEngineFunc'-osoittimelle. Sen alapuolella kutsumme tätä toimintoa välittämällä objektin nimen yhdessä 'carEngineFunc' -viitteen kanssa.
Koodi 3:
#includekäyttäen nimiavaruutta std ;
luokan MyNewCar {
julkinen :
mitätön startCarEngine ( ) {
cout << 'Auton moottori käynnistyy' << endl ;
}
mitätön stopCarEngine ( ) {
cout << 'Auton moottori pysähtyy' << endl ;
}
} ;
int pää ( ) {
mitätön ( Uusi autoni ::* carEngineFunc ) ( ) ;
MyNewCar myCar_obj ;
carEngineFunc = & Uusi autoni :: startCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
carEngineFunc = & Uusi autoni :: stopCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
palata 0 ;
}
Lähtö:
Täällä näytetään 'jäsenfunktioosoittimen' toiminta. Näemme, että loimme jäsenfunktioosoittimen ja näytimme tuloksen täällä.
Esimerkki 4:
Kun olet sisällyttänyt otsikkotiedoston ja 'std-nimiavaruuden', määritämme 'MyNewStudent'-luokan tähän. ' StudentPass()' -jäsenfunktio on yksi jäsenfunktioista, jotka rakennamme täällä luomaamme 'MyStudentClass' -luokkaan. Lisäämme tähän funktioon myös 'cout', joka hahmonnetaan, kun kutsumme sitä koodissamme.
Seuraavaksi kirjoitamme 'studentFail()' -jäsenfunktion, jossa käytämme 'cout' vielä kerran. Main()-funktiota kutsutaan sitten ja jäsenfunktion osoitin '(MyNewStudent::*studentResultFunc)()' ilmoitetaan. Sen alapuolelle luomme 'myStd_obj' -objektin, joka kuuluu 'MyNewStudent'-luokkaan.
Seuraavaksi määritämme 'studentPass'-funktion 'studentResultFunc'-osoittimelle. Sen alapuolella kutsumme tätä funktiota välittämällä objektin nimen yhdessä 'studentResultFunc' -viitteen kanssa. Funktio 'studentFail' on määritetty uudelleen ' studentResultFunc ' -osoittimelle. Sen alapuolella kutsumme tätä menetelmää antamalla 'carEngineFunc' -viittauksen ja objektin nimen.
Nyt molempia funktioita kutsutaan tässä ja lausekkeet, jotka sisällytimme näihin funktioihin, hahmonnetaan.
Koodi 4:
#includekäyttäen nimiavaruutta std ;
luokan MyNewStudent {
julkinen :
mitätön opiskelijapassi ( ) {
cout << 'Oppilaspassi' << endl ;
}
mitätön opiskelijaFail ( ) {
cout << 'Oppilas epäonnistuu' << endl ;
}
} ;
int pää ( ) {
mitätön ( MyNewStudent ::* opiskelijaResultFunc ) ( ) ;
MyNewStudent myStd_obj ;
opiskelijaResultFunc = & MyNewStudent :: opiskelijapassi ;
( myStd_obj. * opiskelijaResultFunc ) ( ) ;
opiskelijaResultFunc = & MyNewStudent :: opiskelijaFail ;
( myStd_obj. * opiskelijaResultFunc ) ( ) ;
palata 0 ;
}
Lähtö:
Loimme jäsenfunktiot koodiimme ja sitten jäsenfunktioosoittimen. Tämän jälkeen kutsuimme jäsenfunktiota ja näytimme tuloksen tässä.
Esimerkki 5:
'SampleClass' luodaan tässä tapauksessa. Sitten jäsenfunktion osoitin sijoitetaan tähän, joka on '(SampleClass::*MyFunc)()'. Tämän alle luomme funktioosoittimen, joka on '(*MyFuncPtr)()'. Sen alapuolella ilmoitamme 'merkkijono'-muuttujan 'nimi' sekä 'MyFunc f' -jäsenfunktioosoittimen.
Tämän jälkeen meillä on 'julkinen' konstruktori, jossa määritämme tämän jäsenfunktiomuuttujan. Tämän alapuolelle luomme jäsenfunktiot nimeltä 'myFunc_1()' ja 'myFunc_1()' ja lisäämme myös 'cout' jokaiseen jäsenfunktioon, joka näkyy, kun kutsumme tätä jäsenfunktiota.
Sitten kutsumme tätä jäsenfunktion osoitinta '(this->*f)()' avulla. Sitten asetamme funktiot uudelleen. Täällä muutamme aiemmin lisäämiämme 'cout'-lauseita. Sitten 'main()' kutsutaan nyt ja jäsenfunktion osoitin määritellään 'MyFunc f = &SampleClass::myFunc_2'.
Sitten funktioosoitin määritellään myös nimellä 'MyFuncPtr fp = myFunc_1'. Tämän jälkeen kirjoitamme '(a.*f)()' käyttääksemme jäsenfunktion osoitinta. 'b.func' on sijoitettu käyttämään jäsentoimintoa. Sitten asetamme 'fp()' kutsumaan funktioosoittimen.
Koodi 5:
#includekäyttäen nimiavaruutta std ;
luokka SampleClass ;
typedef mitätön ( Näyteluokka ::* MyFunc ) ( ) ;
typedef mitätön ( * MyFuncPtr ) ( ) ;
luokka SampleClass {
merkkijonon nimi ;
MyFunc f ;
julkinen :
Näyteluokka ( konst hiiltyä * nimi )
: nimi ( nimi ) ,
f ( & Näyteluokka :: myFunc_1 )
{ }
mitätön myFunc_1 ( ) { cout << nimi << 'Soitimme fuction 1:n tänne' << endl ; }
mitätön myFunc_2 ( ) { cout << nimi << 'Soitimme funktiota 2 täällä' << endl ; }
mitätön func ( ) {
( Tämä ->* f ) ( ) ;
}
} ;
mitätön myFunc_1 ( ) { cout << 'Ensimmäinen toiminto' << endl ; }
mitätön myFunc_2 ( ) { cout << 'Toinen toiminto' << endl ; }
int pää ( )
{
MyFunc f = & Näyteluokka :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
Näyteluokka a ( 'ensimmäinen -' ) , b ( 'toinen -' ) ;
( a. * f ) ( ) ;
b. func ( ) ;
fp ( ) ;
}
Lähtö:
Koodin tulos hahmonnetaan nyt tässä, mikä hahmontaa tuloksen vastaavasti, kuten kutsuimme koodimme funktioita.
Johtopäätös
Tutkimme, että C++:n 'jäsenfunktioosoittimet' helpottavat dynaamista sidontaa, käyttäytymisen kapseloimista ja funktion kutsumisen joustavaa käsittelyä OOP:n yhteydessä. Opimme, että 'jäsentoimintoosoittimien' käyttö voi parantaa merkittävästi C++-koodikantojen modulaarisuutta ja joustavuutta, mikä tarjoaa tehokkaan työkalun lukuisiin suunnittelu- ja ajonaikaisiin haasteisiin vastaamiseen.