1. példa:
Az „iostream” fejlécfájlt mellékeljük, hogy megkönnyítsük a meghatározott funkciók használatát. Ezután megvan a „névtér std”. Ez alatt létrehozzuk a „MyNewClass” nevű osztályt, és használjuk a „nyilvános” konstruktort.
A „public”-ban létrehozzuk a „myFunc” nevű tagfüggvényt, és a „myFunc()” paramétereként az „int num”-t deklaráljuk. Ez alatt a „cout”-t használjuk, és ez alatt hívjuk meg a main() metódust, amelyben létrehozzuk a tagfüggvény-mutatót. A „MyFuncPtr” mutatót deklaráljuk a tagfüggvény típusára, megadva a „MyNewClass” osztályt és a paraméter típusát (int).
Ezt követően létrehozzuk a „Class_obj” nevű osztályobjektumot, majd a „*MyFuncPtr” mutató segítségével meghívjuk a tagfüggvényt, ezzel elhelyezve az osztályobjektumot. A „10”-et adjuk meg paraméterként ennek megjelenítéséhez, amikor meghívjuk a tagfüggvény-mutatót.
1. kód:
#includenévtér std használatával ;
osztály MyNewClass {
nyilvános :
üres myFunc ( int az egyiken ) {
cout << 'Az érték' << az egyiken << endl ;
}
} ;
int fő- ( ) {
üres ( MyNewClass ::* MyFuncPtr ) ( int ) = & MyNewClass :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
Visszatérés 0 ;
}
Kimenet:
Ez szemlélteti a tagfüggvény-mutatók működését. A tagfüggvény mutatója használható a tagfüggvények dinamikus elindítására az aktuális feltételeknek megfelelően.
2. példa:
Az „iostream” fejlécfájlban definiált függvények egyszerű használatához az „iostream”-t is felvesszük ide. A „namespace std” a következő helyen található. Alatta létrehozzuk a „Teszt” osztályt, majd használjuk a „nyilvános” konstruktort. A „myTestingFunc” tagfüggvényt a „public”-ban határozzuk meg, és ebben az esetben az „int t_value”-t állítjuk be a „myTestingFunc()” paramétereként. Az alábbiakban a „cout” függvényt használjuk, és a main() metódust hívjuk meg. Ezután létrehozzuk a tagfüggvény-mutatót.
Itt adjuk meg a „Test” osztályt és a „*MyTestFuncPtr” tagfüggvény mutatót. A „&Test::myTestingFunc”-t hozzárendeljük a tagfüggvény-mutatóhoz, amely „void (Test::*MyTestFuncPtr)(int)”-ként van deklarálva.
Ezután létrehozzuk a „t_obj” osztályobjektumot, és ezzel hívjuk meg a tagfüggvényt az osztályobjektum elhelyezésével és a „*MyTestFuncPtr” mutató használatával. Ahhoz, hogy ez megjelenjen a tagfüggvény-mutató meghívásakor, a „932”-t adjuk hozzá paraméterként.
2. kód:
#includenévtér std használatával ;
osztály Teszt {
nyilvános :
üres myTestingFunc ( int t_value ) {
cout << 'A tesztelési érték' << t_value << endl ;
}
} ;
int fő- ( ) {
üres ( Teszt ::* MyTestFuncPtr ) ( int ) = & Teszt :: myTestingFunc ;
Teszt t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
Visszatérés 0 ;
}
Kimenet:
Az adott kód végeredménye megjelenik. Láthatjuk, hogy a „tagfüggvény-mutatót” hívtuk meg az osztályobjektummal, ahogy az itt látható.
3. példa:
Az osztály, amelyet ebben a kódban generálunk, a „MyNewCar”, ahol a „public” konstruktort használjuk, és létrehozzuk benne a „startCarEngine()” tagfüggvényt. Ebben a függvényben hozzáadjuk a „cout”-ot, amely akkor jelenik meg, amikor meghívjuk ezt a függvényt a kódunkban. Ezután létrehozunk egy másik tagfüggvényt, amely a „stopCarEngine()”, és ebben a tagfüggvényben ismét a „cout”-t használjuk.
Ezt követően meghívjuk a main() függvényt, majd deklaráljuk a tagfüggvény-mutatót, ami a „MyNewCar::*carEngineFunc()”. Ez alatt létrehozzuk a „MyNewCar” osztályobjektumot „myCar_obj” néven. Ezután hozzárendeljük a „startCarEngine” funkciót a „carEngineFunc” mutatóhoz. Ez alatt a „carEngineFunc” mutató segítségével hívjuk meg ezt a függvényt úgy, hogy mellé helyezzük az objektum nevét.
Ezután újra hozzárendeljük a „stopCarEngine” funkciót a „carEngineFunc” mutatóhoz. Ez alatt a függvényt úgy hívjuk meg, hogy az objektum nevét a „carEngineFunc” hivatkozással együtt adjuk át.
3. kód:
#includenévtér std használatával ;
osztályú MyNewCar {
nyilvános :
üres startCarEngine ( ) {
cout << 'Az autó motorja beindul' << endl ;
}
üres stopCarEngine ( ) {
cout << 'Az autó motorja leáll' << endl ;
}
} ;
int fő- ( ) {
üres ( Az új autóm ::* carEngineFunc ) ( ) ;
MyNewCar myCar_obj ;
carEngineFunc = & Az új autóm :: startCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
carEngineFunc = & Az új autóm :: stopCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
Visszatérés 0 ;
}
Kimenet:
Itt a „tagfüggvény-mutató” működése jelenik meg. Láthatjuk, hogy létrehoztuk a tagfüggvény mutatót, és itt megjelenítettük az eredményt.
4. példa:
A fejlécfájl és az „std névtér” megadása után itt deklaráljuk a „MyNewStudent” osztályt. A ” studentPass()” tagfüggvény egyike azon tagfüggvényeknek, amelyeket az itt generált „MyStudentClass” osztályhoz építünk. Ehhez a függvényhez hozzáadjuk a „cout”-ot is, amely akkor jelenik meg, amikor meghívjuk a kódunkban.
Ezután írjuk a „studentFail()” tagfüggvényt, ahol még egyszer használjuk a „cout”-ot. Ezután a main() függvény meghívásra kerül, és deklarálódik a „(MyNewStudent::*studentResultFunc)()” tagfüggvény-mutató. Ez alatt létrehozzuk a „myStd_obj” objektumot, amely a „MyNewStudent” osztályhoz tartozik.
Ezután hozzárendeljük a „studentPass” függvényt a „studentResultFunc” mutatóhoz. Ez alatt a függvényt úgy hívjuk meg, hogy az objektum nevét a „studentResultFunc” hivatkozással együtt adjuk át. A „studentFail” függvény újra hozzá van rendelve a „ studentResultFunc ” mutatóhoz. Ez alatt a „carEngineFunc” hivatkozás és az objektumnév megadásával hívjuk meg ezt a metódust.
Most itt mindkét függvény meghívásra kerül, és az ezekben a függvényekben szereplő utasítások megjelennek.
4. kód:
#includenévtér std használatával ;
osztály MyNewStudent {
nyilvános :
üres StudentPass ( ) {
cout << 'A diákbérlet' << endl ;
}
üres diákFail ( ) {
cout << 'A diák megbukik' << endl ;
}
} ;
int fő- ( ) {
üres ( MyNewStudent ::* diákResultFunc ) ( ) ;
MyNewStudent myStd_obj ;
diákResultFunc = & MyNewStudent :: StudentPass ;
( myStd_obj. * diákResultFunc ) ( ) ;
diákResultFunc = & MyNewStudent :: diákFail ;
( myStd_obj. * diákResultFunc ) ( ) ;
Visszatérés 0 ;
}
Kimenet:
A kódunkban létrehoztuk a tagfüggvényeket, majd a tagfüggvény-mutatót. Ezt követően meghívtuk a tagfüggvényt, és itt megjelenítettük az eredményt.
5. példa:
A „SampleClass” ebben az esetben jön létre. Ezután ide kerül a tagfüggvény-mutató, ami a következő: „(SampleClass::*MyFunc)()”. Ez alatt létrehozzuk a „(*MyFuncPtr)()” függvénymutatót. Alatta deklaráljuk a „string” változó „nevét”, valamint a „MyFunc f” tagfüggvény mutatóját.
Ezek után megvan a „public” konstruktor, ahol definiáljuk ezt a tagfüggvény változót. Ez alatt létrehozzuk a „myFunc_1()” és „myFunc_1()” nevű tagfüggvényeket, és minden tagfüggvényhez hozzáadjuk a „cout”-t, amely akkor jelenik meg, amikor ezt a tagfüggvényt hívjuk.
Ezután ezt a tagfüggvény-mutatót a „(this->*f)()” segítségével hívjuk meg. Ezután ismét elhelyezzük a függvényeket. Itt megváltoztatjuk a korábban hozzáadott „cout” utasításokat. Ezután a „main()” meghívásra kerül, és a tagfüggvény-mutatót a következőképpen határozzuk meg: „MyFunc f = &SampleClass::myFunc_2”.
Ezután a függvénymutatót a következőképpen definiáljuk: „MyFuncPtr fp = myFunc_1”. Ezután beírjuk az „(a.*f)()”-t a tagfüggvény-mutató használatához. A „b.func” a tagfüggvény használatára van elhelyezve. Ezután az „fp()”-t helyezzük el a függvénymutató meghívásához.
5. kód:
#includenévtér std használatával ;
osztály SampleClass ;
typedef üres ( SampleClass ::* MyFunc ) ( ) ;
typedef üres ( * MyFuncPtr ) ( ) ;
osztály SampleClass {
karakterlánc neve ;
MyFunc f ;
nyilvános :
SampleClass ( const char * név )
: név ( név ) ,
f ( & SampleClass :: myFunc_1 )
{ }
üres myFunc_1 ( ) { cout << név << 'Itt hívtuk az 1-es funkciót' << endl ; }
üres myFunc_2 ( ) { cout << név << 'Itt meghívtuk a 2-es függvényt' << endl ; }
üres func ( ) {
( ez ->* f ) ( ) ;
}
} ;
üres myFunc_1 ( ) { cout << 'Az első funkció' << endl ; }
üres myFunc_2 ( ) { cout << 'A második funkció' << endl ; }
int fő- ( )
{
MyFunc f = & SampleClass :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
Mintaosztály a ( 'első - ' ) , b ( 'második -' ) ;
( a. * f ) ( ) ;
b. func ( ) ;
fp ( ) ;
}
Kimenet:
A kód végeredménye most itt jelenik meg, amely ennek megfelelően jeleníti meg az eredményt, ahogy a kódunkban szereplő függvényeket neveztük.
Következtetés
Feltártuk, hogy a C++ „tagfüggvény-mutatói” megkönnyítik a dinamikus kötést, a viselkedés beágyazását és a függvényhívások rugalmas kezelését az OOP kontextusában. Megtudtuk, hogy a „tagfüggvény-mutatók” használata jelentősen javíthatja a C++ kódbázisok modularitását és rugalmasságát, hatékony eszközt biztosítva számos tervezési és futási kihívás kezelésére.