Primer 1:
Vključujemo datoteko glave »iostream«, da olajšamo uporabo definiranih funkcij. Nato imamo 'namespace std'. Pod tem ustvarimo razred z imenom 'MyNewClass' in uporabimo 'javni' konstruktor.
V »public« ustvarimo funkcijo člana z imenom »myFunc« in deklariramo »int num« kot parameter »myFunc()«. Pod tem uporabimo »cout« in prikličemo metodo main() pod tem, v kateri ustvarimo kazalec funkcije člana. Kazalec »MyFuncPtr« deklariramo na tip funkcije člana, pri čemer navedemo razred »MyNewClass« in tip parametra (int).
Po tem ustvarimo objekt razreda z imenom 'Class_obj' in nato pokličemo funkcijo člana s pomočjo kazalca '*MyFuncPtr', tako da objekt razreda postavimo s tem. Kot parameter za upodobitev tega dodelimo »10«, ko pokličemo kazalec funkcije člana.
Koda 1:
#includeuporaba imenskega prostora std ;
razred MyNewClass {
javnosti :
praznina myFunc ( int na enem ) {
cout << 'Vrednost je' << na enem << konec ;
}
} ;
int glavni ( ) {
praznina ( MojNoviRazred ::* MyFuncPtr ) ( int ) = & MojNoviRazred :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
vrnitev 0 ;
}
Izhod:
To ponazarja delovanje kazalcev funkcij članov. Kazalec članske funkcije lahko uporabite za dinamičen zagon članskih funkcij glede na trenutne pogoje.
Primer 2:
Za preprosto uporabo funkcij, ki so definirane v datoteki glave »iostream«, sem vključimo »iostream«. Naslednji je postavljen »namespace std«. Pod njim ustvarimo razred »Test« in nato uporabimo »javni« konstruktor. Člansko funkcijo » myTestingFunc « definiramo v »public« in nastavimo »int t_value« kot parameter za »myTestingFunc()« v tem primeru. Spodaj se uporablja funkcija »cout« in kliče se metoda main(). Nato ustvarimo kazalec funkcije člana.
Tukaj določimo razred »Test« in kazalec funkcije člana »*MyTestFuncPtr«. »&Test::myTestingFunc« dodelimo kazalcu funkcije članice, ki je deklarirana kot »void (Test::*MyTestFuncPtr)(int)«.
Nato ustvarimo objekt razreda »t_obj« in ga uporabimo za klic funkcije člana tako, da postavimo objekt razreda in uporabimo kazalec »*MyTestFuncPtr«. Da bo to prikazano, ko pokličemo kazalec funkcije člana, kot parameter dodelimo »932«.
Koda 2:
#includeuporaba imenskega prostora std ;
razred Test {
javnosti :
praznina myTestingFunc ( int t_vrednost ) {
cout << 'Testna vrednost je ' << t_vrednost << konec ;
}
} ;
int glavni ( ) {
praznina ( Test ::* MyTestFuncPtr ) ( int ) = & Test :: myTestingFunc ;
Preizkus t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
vrnitev 0 ;
}
Izhod:
Rezultat dane kode je upodobljen. Vidimo lahko, da smo poklicali »kazalec funkcije člana« s predmetom razreda, kot je prikazano tukaj.
Primer 3:
Razred, ki ga ustvarimo v tej kodi, je »MyNewCar«, kjer uporabimo »javni« konstruktor in v njem ustvarimo funkcijo člana, ki je »startCarEngine()«. V to funkcijo dodamo »cout«, ki se upodobi, ko pokličemo to funkcijo v naši kodi. Nato ustvarimo še eno funkcijo člana, ki je »stopCarEngine()« in v tej funkciji članice znova uporabimo »cout«.
Po tem prikličemo funkcijo main() in nato deklariramo kazalec funkcije članice, ki je »MyNewCar::*carEngineFunc()«. Pod tem ustvarimo objekt razreda »MyNewCar« z imenom »myCar_obj«. Nato kazalcu »carEngineFunc« dodelimo funkcijo »startCarEngine«. Pod tem pokličemo to funkcijo s pomočjo kazalca »carEngineFunc«, tako da zraven postavimo ime predmeta.
Nato funkcijo »stopCarEngine« ponovno dodelimo kazalcu »carEngineFunc«. Spodaj to funkcijo pokličemo tako, da posredujemo ime predmeta skupaj s sklicem »carEngineFunc«.
Koda 3:
#includeuporaba imenskega prostora std ;
razreda MyNewCar {
javnosti :
praznina startCarEngine ( ) {
cout << 'Motor avtomobila se zažene' << konec ;
}
praznina stopCarEngine ( ) {
cout << 'Motor avtomobila se ustavi' << konec ;
}
} ;
int glavni ( ) {
praznina ( MyNewCar ::* carEngineFunc ) ( ) ;
MyNewCar myCar_obj ;
carEngineFunc = & MyNewCar :: startCarEngine ;
( mojAvto_obj. * carEngineFunc ) ( ) ;
carEngineFunc = & MyNewCar :: stopCarEngine ;
( mojAvto_obj. * carEngineFunc ) ( ) ;
vrnitev 0 ;
}
Izhod:
Tukaj je prikazano delovanje 'kazalca funkcije člana'. Vidimo, da smo ustvarili kazalec funkcije člana in tukaj prikazali rezultat.
Primer 4:
Po vključitvi datoteke glave in »imenskega prostora std« tukaj deklariramo razred »MyNewStudent«. Članska funkcija »studentPass()« je ena od članskih funkcij, ki jih zgradimo za razred »MyStudentClass«, ki ga ustvarimo tukaj. Tej funkciji dodamo tudi »cout«, ki bo upodobljena, ko jo pokličemo v naši kodi.
Nato napišemo funkcijo člana »studentFail()«, kjer ponovno uporabimo »cout«. Nato se pokliče funkcija main() in deklarira se kazalec funkcije članice »(MyNewStudent::*studentResultFunc)()«. Pod tem ustvarimo objekt ” myStd_obj ”, ki pripada razredu ”MyNewStudent”.
Nato kazalcu »studentResultFunc« dodelimo funkcijo »studentPass«. Spodaj to funkcijo pokličemo tako, da posredujemo ime predmeta skupaj s sklicem »studentResultFunc «. Funkcija »studentFail« je ponovno dodeljena kazalcu »studentResultFunc«. Pod tem prikličemo to metodo tako, da podamo referenco »carEngineFunc« in ime predmeta.
Zdaj se tukaj kličeta obe funkciji in upodobljeni so stavki, ki smo jih vključili v te funkcije.
Koda 4:
#includeuporaba imenskega prostora std ;
razreda MojNoviŠtudent {
javnosti :
praznina študentska vozovnica ( ) {
cout << 'Študentska vozovnica' << konec ;
}
praznina studentFail ( ) {
cout << 'Študent ne uspe' << konec ;
}
} ;
int glavni ( ) {
praznina ( MojNoviŠtudent ::* studentResultFunc ) ( ) ;
MojNoviStudent myStd_obj ;
studentResultFunc = & MojNoviŠtudent :: študentska vozovnica ;
( mojStd_obj. * studentResultFunc ) ( ) ;
studentResultFunc = & MojNoviŠtudent :: studentFail ;
( mojStd_obj. * studentResultFunc ) ( ) ;
vrnitev 0 ;
}
Izhod:
Ustvarili smo funkcije članice v naši kodi in nato kazalec funkcije članice. Po tem smo poklicali funkcijo člana in tukaj prikazali izid.
Primer 5:
V tem primeru je ustvarjen »SampleClass«. Nato se tukaj postavi kazalec funkcije članice, ki je »(SampleClass::*MyFunc)()«. Pod tem ustvarimo kazalec funkcije, ki je »(*MyFuncPtr)()«. Pod njim deklariramo 'ime' spremenljivke 'niz' kot tudi kazalec funkcije članice 'MyFunc f'.
Po tem imamo 'javni' konstruktor, kjer definiramo to spremenljivko funkcije članice. Pod tem ustvarimo funkciji članice z imenom »myFunc_1()« in »myFunc_1()« ter dodamo »cout« v vsako funkcijo članice, ki bo prikazana, ko pokličemo to funkcijo članice.
Nato pokličemo ta kazalec funkcije članice s pomočjo “(this->*f)()”. Nato ponovno postavimo funkcije. Tukaj spremenimo stavke »cout«, ki smo jih predhodno dodali. Nato se zdaj prikliče »main()« in kazalec funkcije članice je definiran kot »MyFunc f = &SampleClass::myFunc_2«.
Nato je tudi kazalec funkcije definiran kot 'MyFuncPtr fp = myFunc_1'. Po tem vnesemo »(a.*f)()«, da uporabimo kazalec funkcije članice. »b.func« je postavljen za uporabo funkcije člana. Nato postavimo »fp()« za klic funkcijskega kazalca.
Koda 5:
#includeuporaba imenskega prostora std ;
razred SampleClass ;
typedef praznina ( SampleClass ::* MyFunc ) ( ) ;
typedef praznina ( * MyFuncPtr ) ( ) ;
razred SampleClass {
ime niza ;
MyFunc f ;
javnosti :
SampleClass ( konst char * ime )
: ime ( ime ) ,
f ( & SampleClass :: myFunc_1 )
{ }
praznina myFunc_1 ( ) { cout << ime << 'Tu smo poklicali funkcijo 1' << konec ; }
praznina myFunc_2 ( ) { cout << ime << 'Tu smo poklicali funkcijo 2' << konec ; }
praznina funk ( ) {
( to ->* f ) ( ) ;
}
} ;
praznina myFunc_1 ( ) { cout << 'Prva funkcija' << konec ; }
praznina myFunc_2 ( ) { cout << 'Druga funkcija' << konec ; }
int glavni ( )
{
MyFunc f = & SampleClass :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
Vzorčni razred a ( 'prvi -' ) , b ( 'drugo -' ) ;
( a. * f ) ( ) ;
b. funk ( ) ;
fp ( ) ;
}
Izhod:
Rezultat kode je zdaj upodobljen tukaj, kar ustrezno upodobi rezultat, kot smo imenovali funkcije v naši kodi.
Zaključek
Raziskali smo, da 'kazalci funkcij članov' v C++ olajšajo dinamično vezavo, enkapsulacijo vedenja in prilagodljivo obravnavanje priklica funkcij v kontekstu OOP. Izvedeli smo, da lahko uporaba 'kazalcev funkcij članov' znatno izboljša modularnost in prilagodljivost kodnih baz C++, kar zagotavlja močno orodje za reševanje številnih izzivov oblikovanja in izvajanja.