Voorbeeld 1:
We voegen het headerbestand “iostream” toe om het gemakkelijk te maken om de gedefinieerde functies te gebruiken. Dan hebben we de 'naamruimte std'. Daaronder genereren we de klasse met de naam “MyNewClass” en gebruiken we de “public” constructor.
In “public” creëren we de lidfunctie met de naam “myFunc” en declareren “int num” als de parameter van “myFunc()”. Hieronder gebruiken we de 'cout' en roepen we de methode main() daaronder aan, waarin we de member-functieaanwijzer creëren. We declareren de “MyFuncPtr”-aanwijzer naar het lidfunctietype, waarbij de klasse “MyNewClass” en het parametertype (int) worden gespecificeerd.
Hierna maken we het klasseobject met de naam “Class_obj” aan en roepen vervolgens de memberfunctie aan met behulp van de “*MyFuncPtr” pointer door het klasseobject hiermee te plaatsen. We wijzen “10” toe als de parameter om dit weer te geven wanneer we de lidfunctieaanwijzer aanroepen.
Code1:
#includenamespace std; gebruiken ;
klasse MijnNieuweKlasse {
openbaar :
leegte mijnFunc ( int op een ) {
uit << 'De waarde is' << op een << eindl ;
}
} ;
int voornaamst ( ) {
leegte ( MijnNieuweKlasse ::* MijnFuncPtr ) ( int ) = & MijnNieuweKlasse :: mijnFunc ;
MijnNieuweKlasse Klasse_obj ;
( Klasse_obj. * MijnFuncPtr ) ( 10 ) ;
opbrengst 0 ;
}
Uitgang:
Dit illustreert de werking van lidfunctieaanwijzers. De lidfunctieaanwijzer kan worden gebruikt om de lidfuncties dynamisch te starten op basis van de huidige omstandigheden.
Voorbeeld 2:
Om de functies die zijn gedefinieerd in het headerbestand “iostream” eenvoudig te gebruiken, nemen we hier “iostream” op. De 'naamruimte std' wordt hierna geplaatst. Daaronder maken we de klasse “Test” en gebruiken vervolgens de constructor “public”. We definiëren de lidfunctie ‘myTestingFunc’ in ‘public’ en stellen in dit geval ‘int t_value’ in als de parameter voor ‘myTestingFunc()’. De functie “cout” wordt hieronder gebruikt en de methode main() wordt aangeroepen. Vervolgens maken we de lidfunctieaanwijzer.
We specificeren hier de klasse 'Test' en de lidfunctieaanwijzer '*MyTestFuncPtr'. We wijzen “&Test::myTestingFunc” toe aan de lidfunctieaanwijzer die is gedeclareerd als “void (Test::*MyTestFuncPtr)(int)”.
Vervolgens genereren we het klassenobject “t_obj” en gebruiken dit om de lidfunctie aan te roepen door het klasseobject te plaatsen en de “*MyTestFuncPtr” -aanwijzer te gebruiken. Om dit te laten zien wanneer we de lidfunctieaanwijzer aanroepen, wijzen we '932' toe als parameter.
Code2:
#includenamespace std; gebruiken ;
klasse Proef {
openbaar :
leegte mijnTestenFunc ( int t_waarde ) {
uit << 'De testwaarde is' << t_waarde << eindl ;
}
} ;
int voornaamst ( ) {
leegte ( Test ::* MijnTestFuncPtr ) ( int ) = & Test :: mijnTestenFunc ;
Test t_obj ;
( t_obj. * MijnTestFuncPtr ) ( 932 ) ;
opbrengst 0 ;
}
Uitgang:
Het resultaat van de gegeven code wordt weergegeven. We kunnen zien dat we de “member function pointer” hebben aangeroepen met het klasseobject, zoals hier wordt weergegeven.
Voorbeeld 3:
De klasse die we in deze code genereren is ‘MyNewCar’, waarbij we de ‘public’-constructor gebruiken en daarin de lidfunctie creëren die ‘startCarEngine()’ is. In deze functie voegen we “cout” toe, dat wordt weergegeven wanneer we deze functie in onze code aanroepen. Vervolgens creëren we een andere lidfunctie die “stopCarEngine()” is en gebruiken we opnieuw “cout” in deze lidfunctie.
Hierna roepen we de functie main() aan en declareren we vervolgens de aanwijzer van de lidfunctie, namelijk “MyNewCar::*carEngineFunc()”. Hieronder maken we het klasseobject “MyNewCar” aan met de naam “myCar_obj”. Vervolgens wijzen we de functie “startCarEngine” toe aan de “carEngineFunc”-aanwijzer. Daaronder roepen we deze functie aan met behulp van de “carEngineFunc”-pointer door de objectnaam erbij te plaatsen.
Vervolgens wijzen we de functie “stopCarEngine” opnieuw toe aan de “carEngineFunc”-aanwijzer. Daaronder noemen we deze functie door de objectnaam samen met de verwijzing “carEngineFunc” door te geven.
Code 3:
#includenamespace std; gebruiken ;
klasse MyNewCar {
openbaar :
leegte startCarEngine ( ) {
uit << 'De motor van de auto start' << eindl ;
}
leegte stopCarEngine ( ) {
uit << 'De motor van de auto stopt' << eindl ;
}
} ;
int voornaamst ( ) {
leegte ( Mijn nieuwe auto ::* autoMotorFunc ) ( ) ;
MijnNieuwe Auto mijnCar_obj ;
autoMotorFunc = & Mijn nieuwe auto :: startCarEngine ;
( mijnCar_obj. * autoMotorFunc ) ( ) ;
autoMotorFunc = & Mijn nieuwe auto :: stopCarEngine ;
( mijnCar_obj. * autoMotorFunc ) ( ) ;
opbrengst 0 ;
}
Uitgang:
Hier wordt de werking van de “member function pointer” weergegeven. We kunnen zien dat we de lidfunctieaanwijzer hebben gemaakt en het resultaat hier hebben weergegeven.
Voorbeeld 4:
Nadat we het headerbestand en de “std-naamruimte” hebben opgenomen, declareren we hier de klasse “MyNewStudent”. De lidfunctie “studentPass()” is een van de lidfuncties die we bouwen voor de klasse “MyStudentClass” die we hier genereren. We voegen ook 'cout' toe aan deze functie, die wordt weergegeven wanneer we deze in onze code aanroepen.
Vervolgens schrijven we de lidfunctie “studentFail()”, waarbij we nogmaals “cout” gebruiken. Vervolgens wordt de functie main() aangeroepen en wordt de lidfunctieaanwijzer “(MyNewStudent::*studentResultFunc)()” gedeclareerd. Daaronder genereren we het object ‘myStd_obj’ dat tot de klasse ‘MyNewStudent’ behoort.
Vervolgens wijzen we de functie “studentPass” toe aan de “studentResultFunc”-aanwijzer. Daaronder noemen we deze functie door de objectnaam samen met de referentie “studentResultFunc” door te geven. De functie “studentFail” wordt opnieuw toegewezen aan de aanwijzer “studentResultFunc”. Daaronder roepen we deze methode aan door de referentie “carEngineFunc” en de objectnaam op te geven.
Nu worden beide functies hier aangeroepen en worden de instructies weergegeven die we in deze functies hebben opgenomen.
Code 4:
#includenamespace std; gebruiken ;
klasse MijnNieuweStudent {
openbaar :
leegte studentenpas ( ) {
uit << 'De studentenpas' << eindl ;
}
leegte studentFail ( ) {
uit << 'De student faalt' << eindl ;
}
} ;
int voornaamst ( ) {
leegte ( MijnNieuweStudent ::* studentResultaatFunc ) ( ) ;
MijnNieuweStudent myStd_obj ;
studentResultaatFunc = & MijnNieuweStudent :: studentenpas ;
( mijnStd_obj. * studentResultaatFunc ) ( ) ;
studentResultaatFunc = & MijnNieuweStudent :: studentFail ;
( mijnStd_obj. * studentResultaatFunc ) ( ) ;
opbrengst 0 ;
}
Uitgang:
We hebben de lidfuncties in onze code gemaakt en vervolgens de lidfunctieaanwijzer. Hierna hebben we de ledenfunctie aangeroepen en hier de uitkomst weergegeven.
Voorbeeld 5:
In dit exemplaar wordt de “SampleClass” gemaakt. Vervolgens wordt hier de lidfunctieaanwijzer geplaatst, namelijk “(SampleClass::*MyFunc)()”. Daaronder creëren we de functieaanwijzer die “(*MyFuncPtr)()” is. Daaronder declareren we de 'naam' van de 'string' -variabele, evenals de 'MyFunc f' -lidfunctieaanwijzer.
Hierna hebben we de “openbare” constructor waarin we deze lidfunctievariabele definiëren. Daaronder creëren we de lidfuncties genaamd “myFunc_1()” en “myFunc_1()” en voegen we ook “cout” toe aan elke lidfunctie, die wordt weergegeven wanneer we deze lidfunctie aanroepen.
Vervolgens noemen we deze lidfunctieaanwijzer met behulp van “(this->*f)()”. Vervolgens plaatsen we de functies opnieuw. Hier wijzigen we de “cout”-verklaringen die we eerder hebben toegevoegd. Vervolgens wordt “main()” nu aangeroepen en wordt de lidfunctieaanwijzer gedefinieerd als “MyFunc f = &SampleClass::myFunc_2”.
Vervolgens wordt de functieaanwijzer ook gedefinieerd als “MyFuncPtr fp = myFunc_1”. Hierna typen we “(a.*f)()” om de lidfunctieaanwijzer te gebruiken. De “b.func” is geplaatst om de ledenfunctie te gebruiken. Vervolgens plaatsen we “fp()” om de functieaanwijzer aan te roepen.
Code 5:
#includenamespace std; gebruiken ;
klasse VoorbeeldKlasse ;
typedef leegte ( VoorbeeldKlasse ::* MijnFunc ) ( ) ;
typedef leegte ( * MijnFuncPtr ) ( ) ;
klasse VoorbeeldKlasse {
tekenreeks naam ;
MijnFunc f ;
openbaar :
VoorbeeldKlasse ( const verkoold * naam )
: naam ( naam ) ,
F ( & VoorbeeldKlasse :: mijnFunc_1 )
{ }
leegte mijnFunc_1 ( ) { uit << naam << 'We hebben hier fuctie 1 gebeld' << eindl ; }
leegte mijnFunc_2 ( ) { uit << naam << 'We hebben hier functie 2 gebeld' << eindl ; }
leegte func ( ) {
( dit ->* F ) ( ) ;
}
} ;
leegte mijnFunc_1 ( ) { uit << 'De eerste functie' << eindl ; }
leegte mijnFunc_2 ( ) { uit << 'De tweede functie' << eindl ; }
int voornaamst ( )
{
MijnFunc f = & VoorbeeldKlasse :: mijnFunc_2 ;
MyFuncPtr fp = mijnFunc_1 ;
VoorbeeldKlasse a ( 'Eerst - ' ) , B ( 'seconde - ' ) ;
( A. * F ) ( ) ;
B. func ( ) ;
fp ( ) ;
}
Uitgang:
De uitkomst van de code wordt nu hier weergegeven, wat het resultaat overeenkomstig weergeeft zoals we de functies in onze code hebben genoemd.
Conclusie
We hebben onderzocht dat “member function pointers” in C++ de dynamische binding, inkapseling van gedrag en flexibele afhandeling van functieaanroep binnen de context van OOP vergemakkelijken. We hebben geleerd dat het gebruik van ‘member function pointers’ de modulariteit en flexibiliteit van C++-codebases aanzienlijk kan verbeteren, waardoor een krachtig hulpmiddel wordt geboden voor het aanpakken van talloze ontwerp- en runtime-uitdagingen.