Exemplul 1:
Includem fișierul antet „iostream” pentru a facilita utilizarea funcțiilor definite. Apoi, avem „namespace std”. Sub aceasta, generăm clasa numită „MyNewClass” și utilizăm constructorul „public”.
În „public”, creăm funcția membru numită „myFunc” și declarăm „int num” ca parametru al „myFunc()”. Sub aceasta, folosim „cout” și invocăm metoda main() sub aceasta, în care creăm indicatorul funcției membru. Declarăm pointerul „MyFuncPtr” la tipul funcției membru, specificând clasa „MyNewClass” și tipul de parametru (int).
După aceasta, creăm obiectul de clasă numit „Class_obj” și apoi apelăm funcția membru cu ajutorul pointerului „*MyFuncPtr” plasând obiectul de clasă cu aceasta. Atribuim „10” ca parametru pentru a reda acest lucru atunci când apelăm indicatorul funcției membru.
Cod 1:
#includefolosind namespace std ;
clasa MyNewClass {
public :
gol myFunc ( int pe unu ) {
cout << 'Valoarea este' << pe unu << endl ;
}
} ;
int principal ( ) {
gol ( MyNewClass ::* MyFuncPtr ) ( int ) = & MyNewClass :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
întoarcere 0 ;
}
Ieșire:
Aceasta ilustrează funcționarea indicatorilor pentru funcțiile membre. Indicatorul pentru funcția membru poate fi folosit pentru a lansa funcțiile membru în mod dinamic, în funcție de condițiile actuale.
Exemplul 2:
Pentru a utiliza funcțiile care sunt definite în fișierul antet „iostream” simplu, includem „iostream” aici. „Std de spațiu de nume” este plasat în continuare. Dedesubt, creăm clasa „Test” și apoi folosim constructorul „public”. Definim funcția membru „myTestingFunc” în „public” și setăm „int t_value” ca parametru pentru „myTestingFunc()” în acest caz. Funcția „cout” este folosită mai jos și este apelată metoda main(). Apoi, creăm indicatorul pentru funcția membru.
Specificăm aici clasa „Test” și indicatorul funcției membru „*MyTestFuncPtr”. Atribuim „&Test::myTestingFunc” indicatorului funcției membru care este declarat ca „void (Test::*MyTestFuncPtr)(int)”.
În continuare, generăm obiectul de clasă „t_obj” și îl folosim pentru a apela funcția membru, punând obiectul clasei și folosind pointerul „*MyTestFuncPtr”. Pentru ca aceasta să fie prezentată atunci când apelăm indicatorul funcției membru, atribuim „932” ca parametru.
Cod 2:
#includefolosind namespace std ;
Test de clasă {
public :
gol myTestingFunc ( int valoare_t ) {
cout << „Valoarea de testare este” << valoare_t << endl ;
}
} ;
int principal ( ) {
gol ( Test ::* MyTestFuncPtr ) ( int ) = & Test :: myTestingFunc ;
Testează t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
întoarcere 0 ;
}
Ieșire:
Rezultatul codului dat este redat. Putem vedea că am numit „pointerul funcției membru” cu obiectul clasei așa cum se arată aici.
Exemplul 3:
Clasa pe care o generăm în acest cod este „MyNewCar” unde utilizăm constructorul „public” și creăm funcția membru în acesta, care este „startCarEngine()”. În această funcție, adăugăm „cout” care se redă atunci când apelăm această funcție în codul nostru. Apoi, creăm o altă funcție membru care este „stopCarEngine()” și folosim din nou „cout” în această funcție membru.
După aceasta, invocăm funcția main() și apoi declarăm indicatorul funcției membru care este „MyNewCar::*carEngineFunc()”. Sub aceasta, creăm obiectul clasei „MyNewCar” cu numele „myCar_obj”. Apoi, atribuim funcția „startCarEngine” pointerului „carEngineFunc”. Sub aceasta, numim această funcție cu ajutorul pointerului „carEngineFunc” prin plasarea numelui obiectului cu ea.
Apoi, reatribuim funcția „stopCarEngine” pointerului „carEngineFunc”. Mai jos, numim această funcție prin trecerea numelui obiectului împreună cu referința „carEngineFunc”.
Cod 3:
#includefolosind namespace std ;
clasa MyNewCar {
public :
gol startCarEngine ( ) {
cout << „Motorul mașinii pornește” << endl ;
}
gol stopCarEngine ( ) {
cout << „Motorul mașinii se oprește” << endl ;
}
} ;
int principal ( ) {
gol ( Mașina mea nouă ::* carEngineFunc ) ( ) ;
MyNewCar myCar_obj ;
carEngineFunc = & Mașina mea nouă :: startCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
carEngineFunc = & Mașina mea nouă :: stopCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
întoarcere 0 ;
}
Ieșire:
Aici este afișată funcționarea „pointerului funcției membru”. Putem vedea că am creat indicatorul pentru funcția membru și am afișat rezultatul aici.
Exemplul 4:
După ce includem fișierul antet și „spațiul de nume std”, declarăm aici clasa „MyNewStudent”. Funcția membru „studentPass()” este una dintre funcțiile membru pe care le construim pentru clasa „MyStudentClass” pe care o generăm aici. Adăugăm, de asemenea, „cout” la această funcție, care se va reda atunci când o numim în codul nostru.
Apoi, scriem funcția membru „studentFail()” în care folosim din nou „cout”. Funcția main() este apoi apelată și indicatorul funcției membru „(MyNewStudent::*studentResultFunc)()” este declarat. Mai jos, generăm obiectul „myStd_obj” care aparține clasei „MyNewStudent”.
Apoi, atribuim funcția „studentPass” pointerului „studentResultFunc”. Mai jos, numim această funcție prin trecerea numelui obiectului împreună cu referința „studentResultFunc”. Funcția „studentResult” este reatribuită pointerului „studentResultFunc”. Mai jos, invocăm această metodă dând referința „carEngineFunc” și numele obiectului.
Acum, ambele funcții sunt numite aici și instrucțiunile pe care le-am inclus în aceste funcții sunt redate.
Cod 4:
#includefolosind namespace std ;
clasa MyNewStudent {
public :
gol studentPass ( ) {
cout << „Permis de student” << endl ;
}
gol studentFail ( ) {
cout << „Elevul eșuează” << endl ;
}
} ;
int principal ( ) {
gol ( Studentul meu nou ::* studentResultFunc ) ( ) ;
MyNewStudent myStd_obj ;
studentResultFunc = & Studentul meu nou :: studentPass ;
( myStd_obj. * studentResultFunc ) ( ) ;
studentResultFunc = & Studentul meu nou :: studentFail ;
( myStd_obj. * studentResultFunc ) ( ) ;
întoarcere 0 ;
}
Ieșire:
Am creat funcțiile membru în codul nostru și apoi indicatorul pentru funcția membru. După aceasta, am apelat funcția membru și am afișat rezultatul aici.
Exemplul 5:
„SampleClass” este creat în acest caz. Apoi, aici este plasat indicatorul funcției membru care este „(SampleClass::*MyFunc)()”. Sub aceasta, creăm indicatorul funcției care este „(*MyFuncPtr)()”. Sub acesta, declarăm „numele” variabilei „șir”, precum și indicatorul funcției membru „MyFunc f”.
După aceasta, avem constructorul „public” unde definim această variabilă de funcție membru. Sub aceasta, creăm funcțiile membre numite „myFunc_1()” și „myFunc_1()” și, de asemenea, adăugăm „cout” în fiecare funcție membru care se va afișa atunci când apelăm această funcție membru.
Apoi, numim acest indicator pentru funcția membru cu ajutorul lui „(this->*f)()”. Apoi, plasăm din nou funcțiile. Aici, schimbăm declarațiile „cout” pe care le-am adăugat anterior. Apoi, „main()” este acum invocat și indicatorul funcției membru este definit ca „MyFunc f = &SampleClass::myFunc_2”.
Apoi, indicatorul funcției este definit și ca „MyFuncPtr fp = myFunc_1”. După aceasta, tastăm „(a.*f)()” pentru a utiliza indicatorul pentru funcția membru. „b.func” este plasat pentru a utiliza funcția membru. Apoi, plasăm „fp()” pentru a apela indicatorul funcției.
Cod 5:
#includefolosind namespace std ;
clasa SampleClass ;
typedef gol ( SampleClass ::* MyFunc ) ( ) ;
typedef gol ( * MyFuncPtr ) ( ) ;
clasa SampleClass {
nume șir ;
MyFunc f ;
public :
SampleClass ( const char * Nume )
: Nume ( Nume ) ,
f ( & SampleClass :: myFunc_1 )
{ }
gol myFunc_1 ( ) { cout << Nume << „Am sunat aici funcția 1” << endl ; }
gol myFunc_2 ( ) { cout << Nume << „Am numit funcția 2 aici” << endl ; }
gol func ( ) {
( acest ->* f ) ( ) ;
}
} ;
gol myFunc_1 ( ) { cout << „Prima funcție” << endl ; }
gol myFunc_2 ( ) { cout << „A doua funcție” << endl ; }
int principal ( )
{
MyFunc f = & SampleClass :: myFunc_2 ;
MyFuncPtr fp = myFunc_1 ;
SampleClass a ( 'primul -' ) , b ( 'al doilea - ' ) ;
( A. * f ) ( ) ;
b. func ( ) ;
fp ( ) ;
}
Ieșire:
Rezultatul codului este acum redat aici, care redă rezultatul în consecință, așa cum am numit funcțiile din codul nostru.
Concluzie
Am explorat faptul că „indicatorii de funcție de membru” în C++ ușurează legarea dinamică, încapsularea comportamentului și gestionarea flexibilă a invocării funcției în contextul OOP. Am aflat că utilizarea „indicatorilor de funcție de membru” poate îmbunătăți semnificativ modularitatea și flexibilitatea bazelor de cod C++, oferind un instrument puternic pentru abordarea numeroaselor provocări de proiectare și de rulare.