1. piemērs:
Mēs iekļaujam “iostream” galvenes failu, lai atvieglotu definēto funkciju izmantošanu. Pēc tam mums ir “namespace std”. Zem tā mēs ģenerējam klasi ar nosaukumu “MyNewClass” un izmantojam “publisko” konstruktoru.
“Publiski” mēs izveidojam dalībnieka funkciju ar nosaukumu “myFunc” un deklarējam “int num” kā “myFunc()” parametru. Zem tā mēs izmantojam “cout” un zem tā izsaucam metodi main(), kurā mēs izveidojam dalībnieka funkcijas rādītāju. Mēs deklarējam “MyFuncPtr” rādītāju dalībnieka funkcijas tipam, norādot klasi “MyNewClass” un parametra veidu (int).
Pēc tam mēs izveidojam klases objektu ar nosaukumu “Class_obj” un pēc tam izsaucam dalībnieka funkciju, izmantojot rādītāju “*MyFuncPtr”, ievietojot klases objektu ar šo. Mēs piešķiram “10” kā parametru, lai to atveidotu, izsaucot dalībnieka funkcijas rādītāju.
1. kods:
#includeizmantojot namespace std ;
klase MyNewClass {
publiski :
nederīgs myFunc ( starpt uz viena ) {
cout << 'Vērtība ir' << uz viena << endl ;
}
} ;
starpt galvenais ( ) {
nederīgs ( Mana Jaunā klase ::* MyFuncPtr ) ( starpt ) = & Mana Jaunā klase :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
atgriezties 0 ;
}
Izvade:
Tas ilustrē dalībnieku funkciju rādītāju darbību. Dalībnieka funkcijas rādītāju var izmantot, lai dinamiski palaistu dalībnieka funkcijas atbilstoši pašreizējiem apstākļiem.
2. piemērs:
Lai izmantotu funkcijas, kas ir definētas galvenes failā “iostream”, mēs šeit iekļaujam “iostream”. Blakus tiek ievietota “namespace std”. Zem tā mēs izveidojam klasi “Test” un pēc tam izmantojam “publisko” konstruktoru. Mēs definējam “myTestingFunc” dalībnieka funkciju “public” un šajā gadījumā iestatām “int t_value” kā “myTestingFunc()” parametru. Tālāk tiek izmantota funkcija “cout” un tiek izsaukta metode main(). Pēc tam mēs izveidojam dalībnieka funkcijas rādītāju.
Šeit mēs norādām klasi “Test” un “*MyTestFuncPtr” dalībnieka funkcijas rādītāju. Mēs piešķiram “&Test::myTestingFunc” dalībnieka funkcijas rādītājam, kas tiek deklarēts kā “nederīgs (Test::*MyTestFuncPtr)(int)”.
Pēc tam mēs ģenerējam klases objektu “t_obj” un izmantojam to, lai izsauktu dalībnieka funkciju, ievietojot klases objektu un izmantojot rādītāju “*MyTestFuncPtr”. Lai tas tiktu parādīts, izsaucot dalībnieka funkcijas rādītāju, mēs piešķiram “932” kā parametru.
2. kods:
#includeizmantojot namespace std ;
klase Tests {
publiski :
nederīgs myTestingFunc ( starpt t_vērtība ) {
cout << 'Pārbaudes vērtība ir' << t_vērtība << endl ;
}
} ;
starpt galvenais ( ) {
nederīgs ( Pārbaude ::* MyTestFuncPtr ) ( starpt ) = & Pārbaude :: myTestingFunc ;
Pārbaudīt t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
atgriezties 0 ;
}
Izvade:
Tiek atveidots dotā koda rezultāts. Mēs redzam, ka mēs izsaucām “biedra funkcijas rādītāju” ar klases objektu, kā parādīts šeit.
3. piemērs:
Klase, ko mēs ģenerējam šajā kodā, ir “MyNewCar”, kurā mēs izmantojam “publisko” konstruktoru un tajā izveidojam dalībnieka funkciju, kas ir “startCarEngine()”. Šajā funkcijā mēs pievienojam “cout”, kas tiek atveidots, kad mēs savā kodā izsaucam šo funkciju. Pēc tam mēs izveidojam citu dalībnieka funkciju, kas ir “stopCarEngine()”, un šajā dalībnieka funkcijā atkal izmantojam “cout”.
Pēc tam mēs izsaucam galveno () funkciju un pēc tam deklarējam dalībnieka funkcijas rādītāju, kas ir “MyNewCar::*carEngineFunc()”. Zem tā mēs izveidojam “MyNewCar” klases objektu ar nosaukumu “myCar_obj”. Pēc tam rādītājam “carEngineFunc” piešķiram funkciju “startCarEngine”. Zem tā mēs izsaucam šo funkciju ar “carEngineFunc” rādītāja palīdzību, ievietojot tai objekta nosaukumu.
Pēc tam mēs atkārtoti piešķiram funkciju “stopCarEngine” rādītājam “carEngineFunc”. Zemāk mēs izsaucam šo funkciju, nododot objekta nosaukumu kopā ar atsauci “carEngineFunc”.
3. kods:
#includeizmantojot namespace std ;
klases MyNewCar {
publiski :
nederīgs startCarEngine ( ) {
cout << 'Automašīnas dzinējs ieslēdzas' << endl ;
}
nederīgs stopCarEngine ( ) {
cout << 'Automašīnas dzinējs apstājas' << endl ;
}
} ;
starpt galvenais ( ) {
nederīgs ( MyNewCar ::* auto DzinējsFunc ) ( ) ;
MyNewCar myCar_obj ;
auto DzinējsFunc = & MyNewCar :: startCarEngine ;
( myCar_obj. * auto DzinējsFunc ) ( ) ;
auto DzinējsFunc = & MyNewCar :: stopCarEngine ;
( myCar_obj. * auto DzinējsFunc ) ( ) ;
atgriezties 0 ;
}
Izvade:
Šeit tiek parādīta “dalībnieka funkcijas rādītāja” darbība. Mēs redzam, ka esam izveidojuši dalībnieka funkcijas rādītāju un šeit parādījuši rezultātu.
4. piemērs:
Pēc galvenes faila un “std nosaukumvietas” iekļaušanas mēs šeit deklarējam klasi “MyNewStudent”. Dalībnieka funkcija ” studentPass()” ir viena no dalībfunkcijām, ko veidojam šeit ģenerētajai klasei “MyStudentClass”. Mēs arī pievienojam šai funkcijai “cout”, kas tiks renderēta, kad mēs to izsauksim savā kodā.
Pēc tam mēs rakstām dalībnieka funkciju “studentFail ()”, kur vēlreiz lietojam “cout”. Pēc tam tiek izsaukta funkcija main() un tiek deklarēts dalībnieka funkcijas rādītājs “(MyNewStudent::*studentResultFunc)()”. Zem tā mēs ģenerējam objektu “myStd_obj”, kas pieder klasei “MyNewStudent”.
Pēc tam rādītājam “studentResultFunc” piešķiram funkciju “studentPass”. Zemāk mēs izsaucam šo funkciju, nododot objekta nosaukumu kopā ar atsauci “studentResultFunc”. Funkcija 'studentFail' tiek atkārtoti piešķirta rādītājam ' studentResultFunc '. Zemāk mēs izsaucam šo metodi, norādot “carEngineFunc” atsauci un objekta nosaukumu.
Tagad šeit tiek izsauktas abas funkcijas un tiek atveidoti priekšraksti, kurus mēs iekļāvām šajās funkcijās.
4. kods:
#includeizmantojot namespace std ;
klase MyNewStudent {
publiski :
nederīgs studentpass ( ) {
cout << 'Studenta caurlaide' << endl ;
}
nederīgs students Fail ( ) {
cout << 'Studentam neizdodas' << endl ;
}
} ;
starpt galvenais ( ) {
nederīgs ( Mans JaunaisStudents ::* studentsResultFunc ) ( ) ;
MyNewStudent myStd_obj ;
studentsResultFunc = & Mans JaunaisStudents :: studentpass ;
( myStd_obj. * studentsResultFunc ) ( ) ;
studentsResultFunc = & Mans JaunaisStudents :: students Fail ;
( myStd_obj. * studentsResultFunc ) ( ) ;
atgriezties 0 ;
}
Izvade:
Mēs savā kodā izveidojām dalībnieka funkcijas un pēc tam dalībnieka funkcijas rādītāju. Pēc tam mēs izsaucām dalībnieka funkciju un šeit parādījām rezultātu.
5. piemērs:
Šajā gadījumā tiek izveidota “SampleClass”. Pēc tam šeit tiek ievietots dalībnieka funkcijas rādītājs, kas ir “(SampleClass::*MyFunc)()”. Zem tā mēs izveidojam funkcijas rādītāju, kas ir “(*MyFuncPtr)()”. Zem tā mēs deklarējam mainīgā 'virknes' nosaukumu, kā arī 'MyFunc f' dalībnieka funkcijas rādītāju.
Pēc tam mums ir “publiskais” konstruktors, kurā mēs definējam šo dalībnieka funkcijas mainīgo. Zem tā mēs izveidojam dalībnieka funkcijas ar nosaukumu “myFunc_1()” un “myFunc_1()”, kā arī pievienojam “cout” katrai dalībnieka funkcijai, kas tiks parādīta, kad izsauksim šo dalībnieka funkciju.
Pēc tam mēs izsaucam šo dalībnieka funkcijas rādītāju, izmantojot “(this->*f)()”. Pēc tam mēs atkal ievietojam funkcijas. Šeit mēs mainām iepriekš pievienotos “cout” paziņojumus. Pēc tam tagad tiek izsaukts “main()” un dalībnieka funkcijas rādītājs tiek definēts kā “MyFunc f = &SampleClass::myFunc_2”.
Pēc tam funkcijas rādītājs tiek definēts arī kā “MyFuncPtr fp = myFunc_1”. Pēc tam mēs ierakstām “(a.*f)()”, lai izmantotu dalībnieka funkcijas rādītāju. “b.func” ir novietots, lai izmantotu dalībnieka funkciju. Pēc tam mēs ievietojam “fp()”, lai izsauktu funkcijas rādītāju.
5. kods:
#includeizmantojot namespace std ;
klase Paraugklase ;
typedef nederīgs ( Parauga klase ::* MyFunc ) ( ) ;
typedef nederīgs ( * MyFuncPtr ) ( ) ;
klase Paraugklase {
virknes nosaukums ;
MyFunc f ;
publiski :
Parauga klase ( konst char * nosaukums )
: nosaukums ( nosaukums ) ,
f ( & Parauga klase :: myFunc_1 )
{ }
nederīgs myFunc_1 ( ) { cout << nosaukums << 'Mēs šeit izsaucām fuction 1' << endl ; }
nederīgs myFunc_2 ( ) { cout << nosaukums << 'Mēs šeit saucām funkciju 2' << endl ; }
nederīgs func ( ) {
( šis ->* f ) ( ) ;
}
} ;
nederīgs myFunc_1 ( ) { cout << 'Pirmā funkcija' << endl ; }
nederīgs myFunc_2 ( ) { cout << 'Otrā funkcija' << endl ; }
starpt galvenais ( )
{
MyFunc f = & Parauga klase :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
Parauga klase a ( 'pirmais -' ) , b ( 'otrais -' ) ;
( a. * f ) ( ) ;
b. func ( ) ;
fp ( ) ;
}
Izvade:
Koda iznākums tagad tiek renderēts šeit, kas attiecīgi atveido rezultātu, kā mēs saucām mūsu koda funkcijas.
Secinājums
Mēs izpētījām, ka “locekļa funkciju norādes” programmā C++ atvieglo dinamisko saistīšanu, uzvedības iekapsulēšanu un funkciju izsaukšanas elastīgu apstrādi OOP kontekstā. Mēs uzzinājām, ka “biedru funkciju rādītāju” izmantošana var ievērojami uzlabot C++ kodu bāzu modularitāti un elastību, nodrošinot jaudīgu rīku daudzu dizaina un izpildlaika problēmu risināšanai.