Halimbawa 1:
Isinasama namin ang 'iostream' na header file upang gawing madaling gamitin ang mga tinukoy na function. Pagkatapos, mayroon kaming 'namespace std'. Sa ilalim nito, binubuo namin ang klase na pinangalanang 'MyNewClass' at ginagamit ang 'pampublikong' constructor.
Sa 'pampubliko', ginagawa namin ang function ng miyembro na pinangalanang 'myFunc' at idineklara ang 'int num' bilang parameter ng 'myFunc()'. Sa ibaba nito, ginagamit namin ang 'cout' at ginagamit ang pangunahing() na pamamaraan sa ibaba nito kung saan ginagawa namin ang pointer ng function ng miyembro. Idineklara namin ang pointer na 'MyFuncPtr' sa uri ng function ng miyembro, na tinutukoy ang klase ng 'MyNewClass' at ang uri ng parameter (int).
Pagkatapos nito, gagawin namin ang class object na pinangalanang 'Class_obj' at pagkatapos ay tawagan ang function ng miyembro sa tulong ng pointer na '*MyFuncPtr' sa pamamagitan ng paglalagay ng class object dito. Itinalaga namin ang '10' bilang parameter upang i-render ito kapag tinawag namin ang pointer ng function ng miyembro.
Code 1:
#includegamit ang namespace std ;
klase MyNewClass {
pampubliko :
walang bisa myFunc ( int sa isa ) {
cout << 'Ang halaga ay' << sa isa << endl ;
}
} ;
int pangunahing ( ) {
walang bisa ( MyNewClass ::* MyFuncPtr ) ( int ) = at MyNewClass :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
bumalik 0 ;
}
Output:
Inilalarawan nito ang paggana ng mga pointer ng function ng miyembro. Magagamit ang pointer ng function ng miyembro para dynamic na ilunsad ang mga function ng miyembro ayon sa mga kasalukuyang kundisyon.
Halimbawa 2:
Upang magamit ang mga function na tinukoy sa 'iostream' na header file na simple, isinama namin ang 'iostream' dito. Ang 'namespace std' ay ilalagay sa susunod. Sa ilalim nito, ginagawa namin ang klase na 'Pagsubok' at pagkatapos ay ginagamit ang 'pampubliko' na tagabuo. Tinutukoy namin ang function ng miyembro ng ' myTestingFunc ' sa 'pampubliko' at itinakda ang 'int t_value' bilang parameter para sa ' myTestingFunc()' sa pagkakataong ito. Ang function na 'cout' ay ginagamit sa ibaba at ang pangunahing() na pamamaraan ay tinatawag. Pagkatapos, nilikha namin ang pointer ng function ng miyembro.
Tinukoy namin ang klase ng 'Pagsubok' at ang pointer ng function ng miyembro ng '*MyTestFuncPtr' dito. Nagtatalaga kami ng '&Test::myTestingFunc' sa pointer ng function ng miyembro na idineklara bilang 'walang bisa (Test::*MyTestFuncPtr)(int)'.
Susunod, binubuo namin ang object ng klase na 't_obj' at ginagamit ito upang tawagan ang function ng miyembro sa pamamagitan ng paglalagay ng object ng klase at paggamit ng pointer na '*MyTestFuncPtr'. Upang maipakita ito kapag tinawag namin ang pointer ng function ng miyembro, itinalaga namin ang '932' bilang parameter.
Code 2:
#includegamit ang namespace std ;
Pagsusulit sa klase {
pampubliko :
walang bisa myTestingFunc ( int t_value ) {
cout << 'Ang halaga ng pagsubok ay' << t_value << endl ;
}
} ;
int pangunahing ( ) {
walang bisa ( Pagsusulit ::* MyTestFuncPtr ) ( int ) = at Pagsusulit :: myTestingFunc ;
Subukan ang t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
bumalik 0 ;
}
Output:
Ang kinalabasan ng ibinigay na code ay nai-render. Makikita natin na tinawag natin ang 'member function pointer' na may class object tulad ng ipinapakita dito.
Halimbawa 3:
Ang klase na nabuo namin sa code na ito ay 'MyNewCar' kung saan ginagamit namin ang 'pampublikong' constructor at lumikha ng function ng miyembro dito na 'startCarEngine()'. Sa function na ito, nagdaragdag kami ng 'cout' na nagre-render kapag tinawag namin ang function na ito sa aming code. Pagkatapos, gumawa kami ng isa pang function ng miyembro na 'stopCarEngine()' at muling ginagamit ang 'cout' sa function ng miyembro na ito.
Pagkatapos nito, i-invoke namin ang main() function at pagkatapos ay idedeklara ang member function pointer na 'MyNewCar::*carEngineFunc()'. Sa ibaba nito, nilikha namin ang object ng klase na 'MyNewCar' na may pangalang, 'myCar_obj'. Pagkatapos, itinalaga namin ang function na 'startCarEngine' sa pointer na 'carEngineFunc'. Sa ilalim nito, tinatawag namin ang function na ito sa tulong ng pointer na 'carEngineFunc' sa pamamagitan ng paglalagay ng pangalan ng bagay dito.
Susunod, itinalaga namin ang function na 'stopCarEngine' sa pointer na 'carEngineFunc'. Sa ibaba nito, tinatawag namin ang function na ito sa pamamagitan ng pagpasa sa pangalan ng object kasama ng reference na 'carEngineFunc'.
Code 3:
#includegamit ang namespace std ;
klase MyNewCar {
pampubliko :
walang bisa simulanCarEngine ( ) {
cout << 'Ang makina ng kotse ay nagsisimula' << endl ;
}
walang bisa stopCarEngine ( ) {
cout << 'Ang makina ng sasakyan ay huminto' << endl ;
}
} ;
int pangunahing ( ) {
walang bisa ( Ang bago kong kotse ::* carEngineFunc ) ( ) ;
MyNewCar myCar_obj ;
carEngineFunc = at Ang bago kong kotse :: simulanCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
carEngineFunc = at Ang bago kong kotse :: stopCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
bumalik 0 ;
}
Output:
Dito, ipinapakita ang paggana ng 'member function pointer'. Nakikita namin na nilikha namin ang pointer ng function ng miyembro at ipinakita ang resulta dito.
Halimbawa 4:
Pagkatapos isama ang header file at ang 'std namespace', ipinapahayag namin ang klase na 'MyNewStudent' dito. Ang function ng miyembro ng ” studentPass()” ay isa sa mga function ng miyembro na binuo namin para sa klase ng “MyStudentClass” na nabuo namin dito. Nagdaragdag din kami ng 'cout' sa function na ito na magre-render kapag tinawag namin ito sa aming code.
Susunod, isinusulat namin ang function ng miyembro na 'studentFail()' kung saan muli naming ginagamit ang 'cout'. Ang main() function ay pagkatapos ay tinatawag at ang '(MyNewStudent::*studentResultFunc)()' member function pointer ay idineklara. Sa ibaba nito, nabuo namin ang bagay na ” myStd_obj ” na kabilang sa klase ng “MyNewStudent”.
Susunod, itinalaga namin ang function na 'studentPass' sa pointer na 'studentResultFunc'. Sa ibaba nito, tinatawag namin ang function na ito sa pamamagitan ng pagpasa sa pangalan ng bagay kasama ng sanggunian na 'studentResultFunc'. Ang function na 'studentFail' ay muling itinalaga sa ' studentResultFunc ' pointer. Sa ibaba nito, ginagamit namin ang pamamaraang ito sa pamamagitan ng pagbibigay ng sanggunian ng 'carEngineFunc' at ang pangalan ng bagay.
Ngayon, ang parehong mga function ay tinatawag dito at ang mga pahayag na kasama namin sa mga function na ito ay nai-render.
Code 4:
#includegamit ang namespace std ;
klase MyNewStudent {
pampubliko :
walang bisa studentPass ( ) {
cout << 'Pasa ng estudyante' << endl ;
}
walang bisa studentFail ( ) {
cout << 'Ang mag-aaral ay nabigo' << endl ;
}
} ;
int pangunahing ( ) {
walang bisa ( MyNewStudent ::* studentResultFunc ) ( ) ;
MyNewStudent myStd_obj ;
studentResultFunc = at MyNewStudent :: studentPass ;
( myStd_obj. * studentResultFunc ) ( ) ;
studentResultFunc = at MyNewStudent :: studentFail ;
( myStd_obj. * studentResultFunc ) ( ) ;
bumalik 0 ;
}
Output:
Nilikha namin ang mga function ng miyembro sa aming code at pagkatapos ay ang pointer ng function ng miyembro. Pagkatapos nito, tinawagan namin ang function ng miyembro at ipinakita ang kinalabasan dito.
Halimbawa 5:
Ang 'SampleClass' ay nilikha sa pagkakataong ito. Pagkatapos, ang pointer ng function ng miyembro ay inilalagay dito na '(SampleClass::*MyFunc)()'. Sa ilalim nito, ginagawa namin ang function pointer na '(*MyFuncPtr)()'. Sa ibaba nito, ipinapahayag namin ang 'pangalan' ng variable na 'string' pati na rin ang pointer ng function ng miyembro ng 'MyFunc f'.
Pagkatapos nito, mayroon kaming 'pampublikong' constructor kung saan namin tinukoy ang variable na function ng miyembro na ito. Sa ilalim nito, nilikha namin ang mga function ng miyembro na pinangalanang 'myFunc_1()' at 'myFunc_1()' at nagdaragdag din ng 'cout' sa bawat function ng miyembro na ipapakita kapag tinawag namin ang function ng miyembro na ito.
Pagkatapos, tinatawag namin itong member function pointer sa tulong ng “(this->*f)()”. Pagkatapos, inilalagay namin muli ang mga pag-andar. Dito, binabago namin ang mga pahayag na 'cout' na dati naming idinagdag. Pagkatapos, ang “main()” ay na-invoke na ngayon at ang member function pointer ay tinukoy bilang “MyFunc f = &SampleClass::myFunc_2”.
Pagkatapos, ang function pointer ay tinukoy din bilang 'MyFuncPtr fp = myFunc_1'. Pagkatapos nito, i-type namin ang '(a.*f)()' para gamitin ang pointer ng function ng miyembro. Ang 'b.func' ay inilagay upang magamit ang function ng miyembro. Pagkatapos, inilalagay namin ang 'fp()' upang tawagan ang function pointer.
Code 5:
#includegamit ang namespace std ;
klase SampleClass ;
typedef walang bisa ( SampleClass ::* MyFunc ) ( ) ;
typedef walang bisa ( * MyFuncPtr ) ( ) ;
klase SampleClass {
pangalan ng string ;
MyFunc f ;
pampubliko :
SampleClass ( const char * pangalan )
: pangalan ( pangalan ) ,
f ( at SampleClass :: myFunc_1 )
{ }
walang bisa myFunc_1 ( ) { cout << pangalan << 'Tinawagan namin ang fuction 1 dito' << endl ; }
walang bisa myFunc_2 ( ) { cout << pangalan << 'Tinawagan namin ang function 2 dito' << endl ; }
walang bisa func ( ) {
( ito ->* f ) ( ) ;
}
} ;
walang bisa myFunc_1 ( ) { cout << 'Ang unang function' << endl ; }
walang bisa myFunc_2 ( ) { cout << 'Ang pangalawang function' << endl ; }
int pangunahing ( )
{
MyFunc f = at SampleClass :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
SampleClass a ( 'una-' ) , b ( 'pangalawa-' ) ;
( a. * f ) ( ) ;
b. func ( ) ;
fp ( ) ;
}
Output:
Ang kinalabasan ng code ay nai-render na ngayon dito na nagre-render ng resulta nang naaayon sa tawag namin sa mga function sa aming code.
Konklusyon
Ginalugad namin na ang 'mga pointer ng function ng miyembro' sa C++ ay nagpapadali sa dynamic na pagbubuklod, encapsulation ng pag-uugali, at flexible na pangangasiwa ng function invocation sa loob ng konteksto ng OOP. Nalaman namin na ang paggamit ng 'mga pointer ng function ng miyembro' ay maaaring makabuluhang mapabuti ang modularity at flexibility ng mga C++ codebase, na nagbibigay ng isang mahusay na tool para sa pagtugon sa maraming mga hamon sa disenyo at runtime.