1 pavyzdys:
Įtraukiame „iostream“ antraštės failą, kad būtų lengva naudoti apibrėžtas funkcijas. Tada turime „vardų erdvę std“. Po juo sugeneruojame klasę pavadinimu „MyNewClass“ ir naudojame „viešąjį“ konstruktorių.
„Viešoje“ mes sukuriame nario funkciją pavadinimu „myFunc“ ir paskelbiame „int num“ kaip „myFunc()“ parametrą. Žemiau mes naudojame „cout“ ir iškviečiame pagrindinį () metodą žemiau, kuriame sukuriame nario funkcijos žymeklį. Mes deklaruojame 'MyFuncPtr' žymeklį į nario funkcijos tipą, nurodydami 'MyNewClass' klasę ir parametro tipą (int).
Po to sukuriame klasės objektą pavadinimu „Class_obj“ ir tada iškviečiame nario funkciją naudodami žymeklį „*MyFuncPtr“, įdėdami klasės objektą su juo. Mes priskiriame „10“ kaip parametrą, kad tai būtų pateikta, kai iškviečiame nario funkcijos žymiklį.
1 kodas:
#includenaudojant vardų sritį std ;
klasė MyNewClass {
viešas :
tuštuma myFunc ( tarpt ant vieno ) {
cout << 'Vertė yra' << ant vieno << endl ;
}
} ;
tarpt pagrindinis ( ) {
tuštuma ( Mano nauja klasė ::* MyFuncPtr ) ( tarpt ) = & Mano nauja klasė :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
grąžinti 0 ;
}
Išvestis:
Tai iliustruoja narių funkcijų rodyklių veikimą. Narių funkcijos žymeklis gali būti naudojamas dinamiškai paleisti nario funkcijas pagal esamas sąlygas.
2 pavyzdys:
Norėdami naudoti funkcijas, kurios yra apibrėžtos „iostream“ antraštės faile paprasta, čia įtraukiame „iostream“. „Vardų erdvė std“ yra šalia. Po juo sukuriame „Test“ klasę ir naudojame „viešąjį“ konstruktorių. Mes apibrėžiame „myTestingFunc“ nario funkciją „public“ ir šiuo atveju nustatome „int t_value“ kaip „myTestingFunc()“ parametrą. Toliau naudojama funkcija „cout“ ir iškviečiamas main() metodas. Tada sukuriame nario funkcijos žymeklį.
Čia nurodome „Test“ klasę ir „*MyTestFuncPtr“ nario funkcijos žymeklį. Priskiriame „&Test::myTestingFunc“ nario funkcijos žymekliui, kuris paskelbiamas kaip „negalioja (Test::*MyTestFuncPtr)(int)“.
Tada sugeneruojame „t_obj“ klasės objektą ir naudojame jį nario funkcijai iškviesti, įdėdami klasės objektą ir naudodami žymeklį „*MyTestFuncPtr“. Kad tai būtų pateikta, kai iškviečiame nario funkcijos žymeklį, kaip parametrą priskiriame „932“.
2 kodas:
#includenaudojant vardų sritį std ;
klasė Testas {
viešas :
tuštuma myTestingFunc ( tarpt t_value ) {
cout << 'Bandymo vertė yra' << t_value << endl ;
}
} ;
tarpt pagrindinis ( ) {
tuštuma ( Testas ::* MyTestFuncPtr ) ( tarpt ) = & Testas :: myTestingFunc ;
Testas t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
grąžinti 0 ;
}
Išvestis:
Pateiktas kodo rezultatas. Matome, kad „nario funkcijos rodyklę“ iškvietėme su klasės objektu, kaip parodyta čia.
3 pavyzdys:
Klasė, kurią generuojame šiame kode, yra „MyNewCar“, kurioje naudojame „viešąjį“ konstruktorių ir sukuriame joje nario funkciją, kuri yra „startCarEngine()“. Šioje funkcijoje pridedame „cout“, kuris rodomas, kai iškviečiame šią funkciją mūsų kode. Tada sukuriame kitą nario funkciją, kuri yra „stopCarEngine()“ ir šioje nario funkcijoje vėl naudojame „cout“.
Po to iškviečiame funkciją main() ir paskelbiame nario funkcijos žymeklį, kuris yra „MyNewCar::*carEngineFunc()“. Po juo sukuriame „MyNewCar“ klasės objektą pavadinimu „myCar_obj“. Tada „carEngineFunc“ žymekliui priskiriame funkciją „startCarEngine“. Po juo mes vadiname šią funkciją naudodami „carEngineFunc“ žymeklį, kartu su ja patalpindami objekto pavadinimą.
Toliau funkciją „stopCarEngine“ iš naujo priskiriame žymekliui „carEngineFunc“. Žemiau mes vadiname šią funkciją perduodant objekto pavadinimą kartu su nuoroda „carEngineFunc“.
3 kodas:
#includenaudojant vardų sritį std ;
klasės MyNewCar {
viešas :
tuštuma startCarEngine ( ) {
cout << „Užsiveda automobilio variklis“ << endl ;
}
tuštuma stopCarEngine ( ) {
cout << 'Automobilio variklis sustoja' << endl ;
}
} ;
tarpt pagrindinis ( ) {
tuštuma ( Mano naujas automobilis ::* carEngineFunc ) ( ) ;
MyNewCar myCar_obj ;
carEngineFunc = & Mano naujas automobilis :: startCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
carEngineFunc = & Mano naujas automobilis :: stopCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
grąžinti 0 ;
}
Išvestis:
Čia rodomas „nario funkcijos rodyklės“ veikimas. Matome, kad sukūrėme nario funkcijos žymeklį ir čia parodėme rezultatą.
4 pavyzdys:
Įtraukę antraštės failą ir „std vardų erdvę“, čia paskelbiame „MyNewStudent“ klasę. StudentPass() nario funkcija yra viena iš narių funkcijų, kurią sukuriame čia sugeneruotai „MyStudentClass“ klasei. Prie šios funkcijos taip pat pridedame „cout“, kuri bus pateikta, kai ją iškviesime savo kode.
Tada parašome „studentFail()“ nario funkciją, kur dar kartą naudojame „cout“. Tada iškviečiama funkcija main() ir paskelbiama „(MyNewStudent::*studentResultFunc)()“ nario funkcijos rodyklė. Žemiau mes sugeneruojame objektą „myStd_obj“, kuris priklauso „MyNewStudent“ klasei.
Tada „studentResultFunc“ žymekliui priskiriame funkciją „studentPass“. Žemiau mes vadiname šią funkciją, perduodant objekto pavadinimą kartu su nuoroda „studentResultFunc“. Funkcija „studentFail“ iš naujo priskiriama žymekliui „studentResultFunc“. Žemiau mes iškviečiame šį metodą pateikdami nuorodą „carEngineFunc“ ir objekto pavadinimą.
Dabar čia iškviečiamos abi funkcijos ir pateikiami teiginiai, kuriuos įtraukėme į šias funkcijas.
4 kodas:
#includenaudojant vardų sritį std ;
klasės „Mano Naujiena“ mokinys {
viešas :
tuštuma studento pažymėjimas ( ) {
cout << „Studento leidimas“ << endl ;
}
tuštuma studentas Fail ( ) {
cout << „Studentui nepasiseka“ << endl ;
}
} ;
tarpt pagrindinis ( ) {
tuštuma ( Mano NaujasisStudentas ::* studentResultFunc ) ( ) ;
MyNewStudent myStd_obj ;
studentResultFunc = & Mano NaujasisStudentas :: studento pažymėjimas ;
( myStd_obj. * studentResultFunc ) ( ) ;
studentResultFunc = & Mano NaujasisStudentas :: studentas Fail ;
( myStd_obj. * studentResultFunc ) ( ) ;
grąžinti 0 ;
}
Išvestis:
Savo kode sukūrėme nario funkcijas, o tada – nario funkcijos žymeklį. Po to iškvietėme nario funkciją ir čia parodėme rezultatą.
5 pavyzdys:
Šiuo atveju sukuriama „SampleClass“. Tada čia dedamas nario funkcijos žymeklis, kuris yra „(SampleClass::*MyFunc)()“. Po juo sukuriame funkcijos žymeklį, kuris yra „(*MyFuncPtr)()“. Po juo deklaruojame „stygos“ kintamojo „pavadinimą“, taip pat „MyFunc f“ nario funkcijos žymeklį.
Po to turime „viešąjį“ konstruktorių, kuriame apibrėžiame šį nario funkcijos kintamąjį. Po juo sukuriame narių funkcijas, pavadintas „myFunc_1()“ ir „myFunc_1()“, taip pat pridedame „cout“ prie kiekvienos nario funkcijos, kuri bus rodoma, kai iškviesime šią nario funkciją.
Tada mes vadiname šio nario funkcijos žymeklį naudodami „(this->*f) ()“. Tada vėl dedame funkcijas. Čia pakeičiame anksčiau pridėtus „cout“ teiginius. Tada iškviečiamas „main()“ ir nario funkcijos rodyklė apibrėžiama kaip „MyFunc f = &SampleClass::myFunc_2“.
Tada funkcijos rodyklė taip pat apibrėžiama kaip „MyFuncPtr fp = myFunc_1“. Po to įrašome „(a.*f)()“, kad panaudotume nario funkcijos žymeklį. „b.func“ įdedamas naudoti nario funkciją. Tada įdedame „fp()“, kad iškviestume funkcijos žymeklį.
5 kodas:
#includenaudojant vardų sritį std ;
klasė SampleClass ;
typedef tuštuma ( SampleClass ::* MyFunc ) ( ) ;
typedef tuštuma ( * MyFuncPtr ) ( ) ;
klasė SampleClass {
eilutės pavadinimas ;
MyFunc f ;
viešas :
SampleClass ( konst char * vardas )
: vardas ( vardas ) ,
f ( & SampleClass :: myFunc_1 )
{ }
tuštuma myFunc_1 ( ) { cout << vardas << „Mes čia iškvietėme 1-ąją funkciją“ << endl ; }
tuštuma myFunc_2 ( ) { cout << vardas << „Čia iškvietėme 2 funkciją“ << endl ; }
tuštuma func ( ) {
( tai ->* f ) ( ) ;
}
} ;
tuštuma myFunc_1 ( ) { cout << „Pirmoji funkcija“ << endl ; }
tuštuma myFunc_2 ( ) { cout << 'Antra funkcija' << endl ; }
tarpt pagrindinis ( )
{
MyFunc f = & SampleClass :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
Mėginio klasė a ( 'Pirmas - ' ) , b ( 'antrasis -' ) ;
( a. * f ) ( ) ;
b. func ( ) ;
fp ( ) ;
}
Išvestis:
Kodo rezultatas dabar pateikiamas čia, o rezultatas atitinkamai pateikiamas taip, kaip vadinome funkcijas savo kode.
Išvada
Ištyrėme, kad „nario funkcijų rodyklės“ programoje C++ palengvina dinaminį susiejimą, elgsenos inkapsuliavimą ir lankstų funkcijų iškvietimo tvarkymą OOP kontekste. Sužinojome, kad „narių funkcijų rodyklių“ naudojimas gali žymiai pagerinti C++ kodų bazių moduliškumą ir lankstumą, suteikdamas galingą įrankį sprendžiant daugybę projektavimo ir vykdymo laiko iššūkių.