Eksempel 1:
Vi inkluderer 'iostream'-headerfilen for å gjøre det enkelt å bruke de definerte funksjonene. Deretter har vi 'navneområdet std'. Under dette genererer vi klassen kalt 'MyNewClass' og bruker den 'offentlige' konstruktøren.
I 'public' oppretter vi medlemsfunksjonen kalt 'myFunc' og erklærer 'int num' som parameteren til 'myFunc()'. Under dette bruker vi 'cout' og påkaller main()-metoden under denne der vi lager medlemsfunksjonspekeren. Vi erklærer 'MyFuncPtr'-pekeren til medlemsfunksjonstypen, og spesifiserer 'MyNewClass'-klassen og parametertypen (int).
Etter dette lager vi klasseobjektet kalt 'Class_obj' og kaller deretter medlemsfunksjonen ved hjelp av '*MyFuncPtr'-pekeren ved å plassere klasseobjektet med denne. Vi tildeler '10' som parameteren for å gjengi dette når vi kaller medlemsfunksjonspekeren.
Kode 1:
#includebruker navneområde std ;
klasse MyNewClass {
offentlig :
tomrom myFunc ( int på en ) {
cout << 'Verdien er' << på en << endl ;
}
} ;
int hoved- ( ) {
tomrom ( MyNewClass ::* MyFuncPtr ) ( int ) = & MyNewClass :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
komme tilbake 0 ;
}
Produksjon:
Dette illustrerer hvordan medlemsfunksjonspekere fungerer. Medlemsfunksjonspekeren kan brukes til å starte medlemsfunksjonene dynamisk i henhold til gjeldende forhold.
Eksempel 2:
For å bruke funksjonene som er definert i 'iostream'-headerfilen enkelt, inkluderer vi 'iostream' her. «navneområdet std» plasseres ved siden av. Under den lager vi 'Test'-klassen og bruker deretter den 'offentlige' konstruktøren. Vi definerer 'myTestingFunc'-medlemsfunksjonen i 'public' og setter 'int t_value' som parameteren for 'myTestingFunc()' i dette tilfellet. 'cout'-funksjonen brukes nedenfor og main()-metoden kalles. Deretter lager vi medlemsfunksjonspekeren.
Vi spesifiserer 'Test'-klassen og '*MyTestFuncPtr' medlemsfunksjonspekeren her. Vi tildeler '&Test::myTestingFunc' til medlemsfunksjonspekeren som er erklært som 'ugyldig (Test::*MyTestFuncPtr)(int)'.
Deretter genererer vi 't_obj'-klasseobjektet og bruker dette til å kalle medlemsfunksjonen ved å sette klasseobjektet og bruke '*MyTestFuncPtr'-pekeren. For at dette skal presenteres når vi kaller medlemsfunksjonspekeren, tildeler vi '932' som parameter.
Kode 2:
#includebruker navneområde std ;
klasseprøve {
offentlig :
tomrom myTestingFunc ( int t_verdi ) {
cout << 'Testverdien er' << t_verdi << endl ;
}
} ;
int hoved- ( ) {
tomrom ( Test ::* MyTestFuncPtr ) ( int ) = & Test :: myTestingFunc ;
Test t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
komme tilbake 0 ;
}
Produksjon:
Utfallet av den gitte koden gjengis. Vi kan se at vi kalte 'medlemsfunksjonspekeren' med klasseobjektet som vist her.
Eksempel 3:
Klassen som vi genererer i denne koden er 'MyNewCar' hvor vi bruker 'public'-konstruktøren og oppretter medlemsfunksjonen i den som er 'startCarEngine()'. I denne funksjonen legger vi til 'cout' som gjengir når vi kaller denne funksjonen i koden vår. Deretter oppretter vi en annen medlemsfunksjon som er 'stopCarEngine()' og bruker 'cout' igjen i denne medlemsfunksjonen.
Etter dette påkaller vi main()-funksjonen og erklærer deretter medlemsfunksjonspekeren som er 'MyNewCar::*carEngineFunc()'. Under dette lager vi klasseobjektet 'MyNewCar' med navnet 'myCar_obj'. Deretter tildeler vi «startCarEngine»-funksjonen til «carEngineFunc»-pekeren. Under denne kaller vi denne funksjonen ved hjelp av 'carEngineFunc'-pekeren ved å plassere objektnavnet med den.
Deretter tilordner vi «stopCarEngine»-funksjonen til «carEngineFunc»-pekeren. Under det kaller vi denne funksjonen ved å sende objektnavnet sammen med 'carEngineFunc'-referansen.
Kode 3:
#includebruker navneområde std ;
klasse MyNewCar {
offentlig :
tomrom startCarEngine ( ) {
cout << 'Motoren til bilen starter' << endl ;
}
tomrom stoppCarEngine ( ) {
cout << 'Motoren til bilen stopper' << endl ;
}
} ;
int hoved- ( ) {
tomrom ( Min nye bil ::* carEngineFunc ) ( ) ;
MyNewCar myCar_obj ;
carEngineFunc = & Min nye bil :: startCarEngine ;
( minCar_obj. * carEngineFunc ) ( ) ;
carEngineFunc = & Min nye bil :: stoppCarEngine ;
( minCar_obj. * carEngineFunc ) ( ) ;
komme tilbake 0 ;
}
Produksjon:
Her vises virkemåten til 'medlemsfunksjonspekeren'. Vi kan se at vi opprettet medlemsfunksjonspekeren og viste resultatet her.
Eksempel 4:
Etter å ha inkludert overskriftsfilen og 'std-navneområdet', erklærer vi klassen 'MyNewStudent' her. 'studentPass()'-medlemsfunksjonen er en av medlemsfunksjonene som vi bygger for 'MyStudentClass'-klassen som vi genererer her. Vi legger også til 'cout' til denne funksjonen som vil gjengi når vi kaller den i koden vår.
Deretter skriver vi 'studentFail()'-medlemsfunksjonen der vi bruker 'cout' en gang til. Main()-funksjonen kalles deretter og “(MyNewStudent::*studentResultFunc)()” medlemsfunksjonspekeren er deklarert. Under det genererer vi ' myStd_obj '-objektet som tilhører klassen 'MyNewStudent'.
Deretter tildeler vi «studentPass»-funksjonen til «studentResultFunc»-pekeren. Nedenfor kaller vi denne funksjonen ved å sende objektnavnet sammen med referansen 'studentResultFunc'. 'studentFail'-funksjonen tilordnes på nytt til ' studentResultFunc '-pekeren. Under det påkaller vi denne metoden ved å gi 'carEngineFunc'-referansen og objektnavnet.
Nå kalles begge funksjonene her og setningene som vi inkluderte i disse funksjonene gjengis.
Kode 4:
#includebruker navneområde std ;
klasse MinNyeStudent {
offentlig :
tomrom studentpass ( ) {
cout << 'studentpasset' << endl ;
}
tomrom studentFail ( ) {
cout << 'Eleven mislykkes' << endl ;
}
} ;
int hoved- ( ) {
tomrom ( Min NyeStudent ::* studentResultFunc ) ( ) ;
MyNewStudent myStd_obj ;
studentResultFunc = & Min NyeStudent :: studentpass ;
( myStd_obj. * studentResultFunc ) ( ) ;
studentResultFunc = & Min NyeStudent :: studentFail ;
( myStd_obj. * studentResultFunc ) ( ) ;
komme tilbake 0 ;
}
Produksjon:
Vi opprettet medlemsfunksjonene i koden vår og deretter medlemsfunksjonspekeren. Etter dette ringte vi medlemsfunksjonen og viste utfallet her.
Eksempel 5:
'SampleClass' opprettes i dette tilfellet. Deretter plasseres medlemsfunksjonspekeren her som er '(SampleClass::*MyFunc)()'. Under denne lager vi funksjonspekeren som er '(*MyFuncPtr)()'. Under den erklærer vi 'navnet' til 'streng'-variabelen så vel som 'MyFunc f' medlemsfunksjonspekeren.
Etter dette har vi den 'offentlige' konstruktøren der vi definerer denne medlemsfunksjonsvariabelen. Under dette lager vi medlemsfunksjonene kalt 'myFunc_1()' og 'myFunc_1()' og legger også til 'cout' i hver medlemsfunksjon som vises når vi kaller denne medlemsfunksjonen.
Deretter kaller vi denne medlemsfunksjonspekeren ved hjelp av '(this->*f)()'. Deretter plasserer vi funksjonene på nytt. Her endrer vi 'cout'-utsagnene som vi tidligere har lagt til. Deretter blir 'main()' nå påkalt og medlemsfunksjonspekeren er definert som 'MyFunc f = &SampleClass::myFunc_2'.
Deretter er funksjonspekeren også definert som 'MyFuncPtr fp = myFunc_1'. Etter dette skriver vi '(a.*f)()' for å bruke medlemsfunksjonspekeren. 'b.func' er plassert for å bruke medlemsfunksjonen. Deretter plasserer vi 'fp()' for å kalle funksjonspekeren.
Kode 5:
#includebruker navneområde std ;
klasse SampleClass ;
typedef tomrom ( SampleClass ::* MyFunc ) ( ) ;
typedef tomrom ( * MyFuncPtr ) ( ) ;
klasse SampleClass {
strengnavn ;
MyFunc f ;
offentlig :
SampleClass ( konst røye * Navn )
: Navn ( Navn ) ,
f ( & SampleClass :: myFunc_1 )
{ }
tomrom myFunc_1 ( ) { cout << Navn << 'Vi kalte funksjon 1 her' << endl ; }
tomrom myFunc_2 ( ) { cout << Navn << 'Vi kalte funksjon 2 her' << endl ; }
tomrom func ( ) {
( dette ->* f ) ( ) ;
}
} ;
tomrom myFunc_1 ( ) { cout << 'Den første funksjonen' << endl ; }
tomrom myFunc_2 ( ) { cout << 'Den andre funksjonen' << endl ; }
int hoved- ( )
{
MyFunc f = & SampleClass :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
Eksempelklasse a ( 'første -' ) , b ( 'sekund - ' ) ;
( en. * f ) ( ) ;
b. func ( ) ;
fp ( ) ;
}
Produksjon:
Resultatet av koden er nå gjengitt her som gjengir resultatet tilsvarende som vi kalte funksjonene i koden vår.
Konklusjon
Vi undersøkte at 'medlemsfunksjonspekere' i C++ letter dynamisk binding, innkapsling av atferd og fleksibel håndtering av funksjonsanrop i sammenheng med OOP. Vi lærte at bruken av 'medlemsfunksjonspekere' kan forbedre modulariteten og fleksibiliteten til C++-kodebaser betydelig, og gir et kraftig verktøy for å håndtere en rekke design- og kjøretidsutfordringer.