Primjer 1:
Uključujemo datoteku zaglavlja 'iostream' kako bismo olakšali korištenje definiranih funkcija. Zatim, imamo “namespace std”. Ispod toga generiramo klasu pod nazivom 'MyNewClass' i koristimo 'javni' konstruktor.
U “public” stvaramo funkciju člana pod nazivom “myFunc” i deklariramo “int num” kao parametar za “myFunc()”. Ispod ovoga, koristimo 'cout' i pozivamo main() metodu ispod ove u kojoj stvaramo pokazivač funkcije članice. Deklariramo pokazivač “MyFuncPtr” na tip funkcije članice, navodeći klasu “MyNewClass” i tip parametra (int).
Nakon toga stvaramo objekt klase pod nazivom “Class_obj” i zatim pozivamo funkciju člana uz pomoć pokazivača “*MyFuncPtr” postavljanjem objekta klase s ovim. Dodjeljujemo '10' kao parametar za prikaz kada pozivamo pokazivač funkcije članice.
Kod 1:
#includekoristeći prostor imena std ;
klasa MojNoviRazred {
javnost :
poništiti myFunc ( int na jedan ) {
cout << 'Vrijednost je' << na jedan << endl ;
}
} ;
int glavni ( ) {
poništiti ( MojNoviRazred ::* MyFuncPtr ) ( int ) = i MojNoviRazred :: myFunc ;
MyNewClass Class_obj ;
( Class_obj. * MyFuncPtr ) ( 10 ) ;
povratak 0 ;
}
Izlaz:
Ovo ilustrira rad pokazivača na funkcije članice. Pokazivač funkcije člana može se koristiti za dinamičko pokretanje funkcija člana prema trenutnim uvjetima.
Primjer 2:
Kako bismo jednostavno koristili funkcije definirane u datoteci zaglavlja 'iostream', ovdje uključujemo 'iostream'. Sljedeći je postavljen 'namespace std'. Ispod njega stvaramo klasu 'Test', a zatim koristimo 'javni' konstruktor. Definiramo funkciju člana 'myTestingFunc' u 'public' i postavljamo 'int t_value' kao parametar za 'myTestingFunc()' u ovom slučaju. U nastavku se koristi funkcija “cout” i poziva se metoda main(). Zatim kreiramo pokazivač funkcije članice.
Ovdje specificiramo klasu “Test” i pokazivač funkcije članice “*MyTestFuncPtr”. Dodjeljujemo “&Test::myTestingFunc” pokazivaču funkcije člana koji je deklariran kao “void (Test::*MyTestFuncPtr)(int)”.
Zatim generiramo objekt klase “t_obj” i koristimo ga za pozivanje funkcije člana stavljanjem objekta klase i korištenjem pokazivača “*MyTestFuncPtr”. Da bi ovo bilo prikazano kada pozivamo pokazivač funkcije članice, dodjeljujemo '932' kao parametar.
Kod 2:
#includekoristeći prostor imena std ;
razred Test {
javnost :
poništiti myTestingFunc ( int t_vrijednost ) {
cout << 'Vrijednost testiranja je ' << t_vrijednost << endl ;
}
} ;
int glavni ( ) {
poništiti ( Test ::* MyTestFuncPtr ) ( int ) = i Test :: myTestingFunc ;
Test t_obj ;
( t_obj. * MyTestFuncPtr ) ( 932 ) ;
povratak 0 ;
}
Izlaz:
Prikazan je ishod zadanog koda. Vidimo da smo pozvali 'pokazivač funkcije članice' s objektom klase kao što je ovdje prikazano.
Primjer 3:
Klasa koju generiramo u ovom kodu je 'MyNewCar' gdje koristimo 'javni' konstruktor i stvaramo funkciju člana u njemu koja je 'startCarEngine()'. U ovu funkciju dodajemo 'cout' koji se renderira kada pozovemo ovu funkciju u našem kodu. Zatim stvaramo još jednu funkciju članicu koja je 'stopCarEngine()' i ponovno koristimo 'cout' u ovoj funkciji članice.
Nakon toga, pozivamo funkciju main() i zatim deklariramo pokazivač funkcije članice koja je “MyNewCar::*carEngineFunc()”. Ispod toga stvaramo objekt klase 'MyNewCar' s imenom 'myCar_obj'. Zatim dodjeljujemo funkciju “startCarEngine” pokazivaču “carEngineFunc”. Ispod toga ovu funkciju pozivamo uz pomoć pokazivača 'carEngineFunc' postavljanjem naziva objekta uz njega.
Zatim ponovno dodjeljujemo funkciju 'stopCarEngine' pokazivaču 'carEngineFunc'. Ispod toga ovu funkciju pozivamo prosljeđivanjem naziva objekta zajedno s referencom 'carEngineFunc'.
Kod 3:
#includekoristeći prostor imena std ;
klasa MyNewCar {
javnost :
poništiti startCarEngine ( ) {
cout << 'Motor automobila se pokreće' << endl ;
}
poništiti stopCarEngine ( ) {
cout << 'Motor automobila staje' << endl ;
}
} ;
int glavni ( ) {
poništiti ( MyNewCar ::* carEngineFunc ) ( ) ;
MojNoviAutomobil myCar_obj ;
carEngineFunc = i MyNewCar :: startCarEngine ;
( mojAutomobil_obj. * carEngineFunc ) ( ) ;
carEngineFunc = i MyNewCar :: stopCarEngine ;
( mojAutomobil_obj. * carEngineFunc ) ( ) ;
povratak 0 ;
}
Izlaz:
Ovdje se prikazuje rad 'pokazivača funkcije članice'. Vidimo da smo stvorili pokazivač funkcije članice i ovdje prikazali rezultat.
Primjer 4:
Nakon što uključimo datoteku zaglavlja i “std namespace”, ovdje deklariramo klasu “MyNewStudent”. Funkcija članica 'studentPass()' jedna je od funkcija članica koje gradimo za klasu 'MyStudentClass' koju ovdje generiramo. Također dodajemo 'cout' ovoj funkciji koja će se prikazati kada je pozovemo u našem kodu.
Zatim pišemo funkciju člana 'studentFail()' gdje još jednom koristimo 'cout'. Zatim se poziva funkcija main() i deklarira se pokazivač funkcije članice “(MyNewStudent::*studentResultFunc)()”. Ispod toga generiramo objekt ” myStd_obj ” koji pripada klasi ”MyNewStudent”.
Zatim dodjeljujemo funkciju “studentPass” pokazivaču “studentResultFunc”. Ispod toga ovu funkciju pozivamo prosljeđivanjem naziva objekta zajedno s referencom “studentResultFunc”. Funkcija “studentFail” ponovno se dodjeljuje pokazivaču “studentResultFunc”. Ispod toga, pozivamo ovu metodu davanjem reference 'carEngineFunc' i naziva objekta.
Sada se ovdje pozivaju obje funkcije i prikazuju se iskazi koje smo uključili u te funkcije.
Kod 4:
#includekoristeći prostor imena std ;
razred MojNoviStudent {
javnost :
poništiti studentPass ( ) {
cout << 'Studentska karta' << endl ;
}
poništiti studentFail ( ) {
cout << 'Pad učenika' << endl ;
}
} ;
int glavni ( ) {
poništiti ( MojNoviStudent ::* studentResultFunc ) ( ) ;
MojNoviStudent myStd_obj ;
studentResultFunc = i MojNoviStudent :: studentPass ;
( mojStd_obj. * studentResultFunc ) ( ) ;
studentResultFunc = i MojNoviStudent :: studentFail ;
( mojStd_obj. * studentResultFunc ) ( ) ;
povratak 0 ;
}
Izlaz:
Stvorili smo funkcije članice u našem kodu, a zatim pokazivač funkcije članice. Nakon toga pozvali smo funkciju člana i ovdje prikazali rezultat.
Primjer 5:
U ovom slučaju kreira se 'SampleClass'. Zatim se ovdje postavlja pokazivač funkcije članice koji je “(SampleClass::*MyFunc)()”. Ispod toga stvaramo pokazivač funkcije koji je '(*MyFuncPtr)()'. Ispod njega deklariramo 'ime' varijable 'string', kao i pokazivač funkcije članice 'MyFunc f'.
Nakon toga, imamo “javni” konstruktor gdje definiramo ovu varijablu funkcije članice. Ispod toga stvaramo funkcije članice pod nazivom “myFunc_1()” i “myFunc_1()” i također dodajemo “cout” u svaku funkciju članicu koja će se prikazati kada pozovemo tu funkciju članicu.
Zatim pozivamo ovaj pokazivač funkcije članice uz pomoć “(this->*f)()”. Zatim ponovno postavljamo funkcije. Ovdje mijenjamo iskaze “cout” koje smo prethodno dodali. Zatim se sada poziva “main()” i pokazivač funkcije članice definira se kao “MyFunc f = &SampleClass::myFunc_2”.
Zatim se pokazivač funkcije također definira kao 'MyFuncPtr fp = myFunc_1'. Nakon toga upisujemo “(a.*f)()” da bismo iskoristili pokazivač funkcije članice. 'b.func' je postavljen za korištenje funkcije člana. Zatim postavljamo 'fp()' da pozovemo pokazivač funkcije.
Kod 5:
#includekoristeći prostor imena std ;
klasa SampleClass ;
typedef poništiti ( SampleClass ::* MyFunc ) ( ) ;
typedef poništiti ( * MyFuncPtr ) ( ) ;
klasa SampleClass {
naziv niza ;
MyFunc f ;
javnost :
SampleClass ( konst char * Ime )
: Ime ( Ime ) ,
f ( i SampleClass :: mojaFunc_1 )
{ }
poništiti mojaFunc_1 ( ) { cout << Ime << 'Ovdje smo pozvali funkciju 1' << endl ; }
poništiti myFunc_2 ( ) { cout << Ime << 'Ovdje smo pozvali funkciju 2' << endl ; }
poništiti funk ( ) {
( ovaj ->* f ) ( ) ;
}
} ;
poništiti mojaFunc_1 ( ) { cout << 'Prva funkcija' << endl ; }
poništiti myFunc_2 ( ) { cout << 'Druga funkcija' << endl ; }
int glavni ( )
{
MyFunc f = i SampleClass :: myFunc_2 ;
MyFuncPtr fp = mojaFunc_1 ;
Klasa uzorka a ( 'prvi -' ) , b ( 'drugi -' ) ;
( a. * f ) ( ) ;
b. funk ( ) ;
fp ( ) ;
}
Izlaz:
Ishod koda sada se prikazuje ovdje što prikazuje rezultat u skladu s tim kako smo nazvali funkcije u našem kodu.
Zaključak
Istražili smo da 'pokazivači na funkcije članice' u C++ olakšavaju dinamičko vezanje, enkapsulaciju ponašanja i fleksibilno rukovanje pozivanjem funkcija unutar konteksta OOP-a. Naučili smo da korištenje 'pokazivača na funkcije članice' može značajno poboljšati modularnost i fleksibilnost baza koda C++, pružajući moćan alat za rješavanje brojnih izazova dizajna i vremena izvođenja.