Exempel 1:
Vi inkluderar rubrikfilen 'iostream' för att göra det enkelt att använda de definierade funktionerna. Sedan har vi 'namnrymden std'. Under detta genererar vi klassen med namnet 'MyNewClass' och använder konstruktorn 'public'.
I 'public' skapar vi medlemsfunktionen med namnet 'myFunc' och deklarerar 'int num' som parametern för 'myFunc()'. Under detta använder vi 'cout' och anropar main()-metoden under denna där vi skapar medlemsfunktionspekaren. Vi förklarar 'MyFuncPtr'-pekaren till medlemsfunktionstypen och anger klassen 'MyNewClass' och parametertypen (int).
Efter detta skapar vi klassobjektet med namnet 'Class_obj' och anropar sedan medlemsfunktionen med hjälp av '*MyFuncPtr'-pekaren genom att placera klassobjektet med detta. Vi tilldelar '10' som parametern för att återge detta när vi anropar medlemsfunktionspekaren.
Kod 1:
#includeanvänder namnutrymme std ;
klass MyNewClass {
offentlig :
tomhet myFunc ( int på ett ) {
cout << 'Värdet är' << på ett << endl ;
}
} ;
int huvud ( ) {
tomhet ( MyNewClass ::* MyFuncPtr ) ( int ) = & MyNewClass :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
lämna tillbaka 0 ;
}
Produktion:
Detta illustrerar hur medlemsfunktionspekare fungerar. Medlemsfunktionspekaren kan användas för att starta medlemsfunktionerna dynamiskt enligt nuvarande förhållanden.
Exempel 2:
För att enkelt använda funktionerna som definieras i 'iostream'-huvudfilen, inkluderar vi 'iostream' här. Namnutrymmet std placeras bredvid. Under den skapar vi klassen 'Test' och använder sedan konstruktorn 'public'. Vi definierar 'myTestingFunc'-medlemsfunktionen i 'public' och ställer in 'int t_value' som parametern för 'myTestingFunc()' i det här fallet. Funktionen 'cout' används nedan och metoden main() anropas. Sedan skapar vi medlemsfunktionspekaren.
Vi specificerar 'Test'-klassen och '*MyTestFuncPtr'-medlemsfunktionspekaren här. Vi tilldelar '&Test::myTestingFunc' till medlemsfunktionspekaren som deklareras som 'void (Test::*MyTestFuncPtr)(int)'.
Därefter genererar vi klassobjektet 't_obj' och använder detta för att anropa medlemsfunktionen genom att placera klassobjektet och använda '*MyTestFuncPtr'-pekaren. För att detta ska presenteras när vi anropar medlemsfunktionspekaren tilldelar vi '932' som parameter.
Kod 2:
#includeanvänder namnutrymme std ;
klass Test {
offentlig :
tomhet myTestingFunc ( int t_värde ) {
cout << 'Testvärdet är' << t_värde << endl ;
}
} ;
int huvud ( ) {
tomhet ( Testa ::* MyTestFuncPtr ) ( int ) = & Testa :: myTestingFunc ;
Testa t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
lämna tillbaka 0 ;
}
Produktion:
Resultatet av den givna koden återges. Vi kan se att vi kallade 'medlemsfunktionspekaren' med klassobjektet som visas här.
Exempel 3:
Klassen som vi genererar i den här koden är 'MyNewCar' där vi använder konstruktorn 'public' och skapar medlemsfunktionen i den som är 'startCarEngine()'. I den här funktionen lägger vi till 'cout' som återges när vi anropar denna funktion i vår kod. Sedan skapar vi en annan medlemsfunktion som är 'stopCarEngine()' och använder 'cout' igen i denna medlemsfunktion.
Efter detta anropar vi funktionen main() och deklarerar sedan medlemsfunktionspekaren som är 'MyNewCar::*carEngineFunc()'. Under detta skapar vi klassobjektet 'MyNewCar' med namnet 'myCar_obj'. Sedan tilldelar vi 'startCarEngine'-funktionen till 'carEngineFunc'-pekaren. Under denna kallar vi denna funktion med hjälp av 'carEngineFunc'-pekaren genom att placera objektnamnet med den.
Därefter tilldelar vi 'stopCarEngine'-funktionen till 'carEngineFunc'-pekaren. Under det kallar vi denna funktion genom att skicka objektnamnet tillsammans med referensen 'carEngineFunc'.
Kod 3:
#includeanvänder namnutrymme std ;
klass MyNewCar {
offentlig :
tomhet startaCarEngine ( ) {
cout << 'Bilens motor startar' << endl ;
}
tomhet stoppaCarEngine ( ) {
cout << 'Bilens motor stannar' << endl ;
}
} ;
int huvud ( ) {
tomhet ( Min nya bil ::* carEngineFunc ) ( ) ;
MyNewCar myCar_obj ;
carEngineFunc = & Min nya bil :: startaCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
carEngineFunc = & Min nya bil :: stoppaCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
lämna tillbaka 0 ;
}
Produktion:
Här visas hur 'medlemsfunktionspekaren' fungerar. Vi kan se att vi skapade medlemsfunktionspekaren och visade resultatet här.
Exempel 4:
Efter att ha inkluderat rubrikfilen och 'std-namnutrymmet', deklarerar vi klassen 'MyNewStudent' här. Medlemsfunktionen ” studentPass()” är en av medlemsfunktionerna som vi bygger för klassen ”MyStudentClass” som vi genererar här. Vi lägger också till 'cout' till den här funktionen som återges när vi anropar den i vår kod.
Därefter skriver vi 'studentFail()'-medlemsfunktionen där vi använder 'cout' en gång till. Main()-funktionen anropas sedan och '(MyNewStudent::*studentResultFunc)()'-medlemsfunktionspekaren deklareras. Under det genererar vi objektet ' myStd_obj ' som tillhör klassen 'MyNewStudent'.
Därefter tilldelar vi 'studentPass'-funktionen till 'studentResultFunc'-pekaren. Under det kallar vi denna funktion genom att skicka objektnamnet tillsammans med referensen 'studentResultFunc'. Funktionen 'studentFail' tilldelas om till ' studentResultFunc '-pekaren. Under det åberopar vi den här metoden genom att ge referensen 'carEngineFunc' och objektnamnet.
Nu anropas båda funktionerna här och påståendena som vi inkluderade i dessa funktioner återges.
Kod 4:
#includeanvänder namnutrymme std ;
klass MyNewStudent {
offentlig :
tomhet studentpass ( ) {
cout << 'Studentpasset' << endl ;
}
tomhet student Underkänd ( ) {
cout << 'Eleven misslyckas' << endl ;
}
} ;
int huvud ( ) {
tomhet ( MyNewStudent ::* studentResultFunc ) ( ) ;
MyNewStudent myStd_obj ;
studentResultFunc = & MyNewStudent :: studentpass ;
( myStd_obj. * studentResultFunc ) ( ) ;
studentResultFunc = & MyNewStudent :: student Underkänd ;
( myStd_obj. * studentResultFunc ) ( ) ;
lämna tillbaka 0 ;
}
Produktion:
Vi skapade medlemsfunktionerna i vår kod och sedan medlemsfunktionspekaren. Efter detta ringde vi medlemsfunktionen och visade resultatet här.
Exempel 5:
'SampleClass' skapas i det här fallet. Sedan placeras medlemsfunktionspekaren här som är '(SampleClass::*MyFunc)()'. Under detta skapar vi funktionspekaren som är '(*MyFuncPtr)()'. Under den deklarerar vi 'namnet' på variabeln 'sträng' samt 'MyFunc f'-medlemsfunktionspekaren.
Efter detta har vi 'public' konstruktorn där vi definierar denna medlemsfunktionsvariabel. Under detta skapar vi medlemsfunktionerna med namnet 'myFunc_1()' och 'myFunc_1()' och lägger även till 'cout' i varje medlemsfunktion som kommer att visas när vi anropar denna medlemsfunktion.
Sedan kallar vi denna medlemsfunktionspekare med hjälp av '(this->*f)()'. Sedan placerar vi funktionerna igen. Här ändrar vi 'cout'-satserna som vi tidigare lagt till. Sedan anropas nu 'main()' och medlemsfunktionspekaren definieras som 'MyFunc f = &SampleClass::myFunc_2'.
Då är funktionspekaren också definierad som 'MyFuncPtr fp = myFunc_1'. Efter detta skriver vi '(a.*f)()' för att använda medlemsfunktionspekaren. 'b.func' placeras för att använda medlemsfunktionen. Sedan placerar vi 'fp()' för att anropa funktionspekaren.
Kod 5:
#includeanvänder namnutrymme std ;
klass SampleClass ;
typdef tomhet ( SampleClass ::* MyFunc ) ( ) ;
typdef tomhet ( * MyFuncPtr ) ( ) ;
klass SampleClass {
strängens namn ;
MyFunc f ;
offentlig :
SampleClass ( konst röding * namn )
: namn ( namn ) ,
f ( & SampleClass :: myFunc_1 )
{ }
tomhet myFunc_1 ( ) { cout << namn << 'Vi kallade funktion 1 här' << endl ; }
tomhet myFunc_2 ( ) { cout << namn << 'Vi kallade funktion 2 här' << endl ; }
tomhet func ( ) {
( detta ->* f ) ( ) ;
}
} ;
tomhet myFunc_1 ( ) { cout << 'Den första funktionen' << endl ; }
tomhet myFunc_2 ( ) { cout << 'Den andra funktionen' << endl ; }
int huvud ( )
{
MyFunc f = & SampleClass :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
SampleClass a ( 'först - ' ) , b ( 'andra -' ) ;
( a. * f ) ( ) ;
b. func ( ) ;
fp ( ) ;
}
Produktion:
Resultatet av koden renderas nu här vilket återger resultatet i enlighet med det som vi kallade funktionerna i vår kod.
Slutsats
Vi undersökte att 'medlemsfunktionspekare' i C++ underlättar dynamisk bindning, inkapsling av beteende och flexibel hantering av funktionsanrop inom ramen för OOP. Vi lärde oss att användningen av 'medlemsfunktionspekare' avsevärt kan förbättra modulariteten och flexibiliteten hos C++-kodbaser, vilket ger ett kraftfullt verktyg för att hantera många utmaningar i design och körning.