Przykład 1:
Aby ułatwić korzystanie ze zdefiniowanych funkcji, dołączamy plik nagłówkowy „iostream”. Następnie mamy „przestrzeń nazw std”. Poniżej generujemy klasę o nazwie „MyNewClass” i korzystamy z konstruktora „public”.
W „public” tworzymy funkcję członkowską o nazwie „myFunc” i deklarujemy „int num” jako parametr „myFunc()”. Poniżej używamy metody „cout” i wywołujemy metodę main(), znajdującą się poniżej, w której tworzymy wskaźnik funkcji składowej. Deklarujemy wskaźnik „MyFuncPtr” na typ funkcji składowej, podając klasę „MyNewClass” i typ parametru (int).
Następnie tworzymy obiekt klasy o nazwie „Class_obj”, a następnie wywołujemy funkcję składową za pomocą wskaźnika „*MyFuncPtr”, umieszczając w nim obiekt klasy. Przypisujemy „10” jako parametr, aby to wyświetlić, gdy wywołujemy wskaźnik funkcji składowej.
Kod 1:
#includeużywając przestrzeni nazw std ;
klasa MojaNowaKlasa {
publiczny :
próżnia mojaFunkcja ( wew na jednego ) {
cout << „Wartość jest” << na jednego << koniec ;
}
} ;
wew główny ( ) {
próżnia ( MojaNowaKlasa ::* MojaFunkcjaPtr ) ( wew ) = & MojaNowaKlasa :: mojaFunkcja ;
MojaNowaKlasa Class_obj ;
( Obiekt_klasy. * MojaFunkcjaPtr ) ( 10 ) ;
powrót 0 ;
}
Wyjście:
To ilustruje działanie wskaźników funkcji składowych. Wskaźnika funkcji składowej można używać do dynamicznego uruchamiania funkcji składowych zgodnie z bieżącymi warunkami.
Przykład 2:
Aby móc korzystać z funkcji zdefiniowanych w prostym pliku nagłówkowym „iostream”, dołączymy tutaj „iostream”. Następnie znajduje się „przestrzeń nazw std”. Pod nią tworzymy klasę „Test”, a następnie używamy konstruktora „public”. Definiujemy funkcję członkowską „myTestingFunc” w „public” i w tym przypadku ustawiamy „int t_value” jako parametr dla „myTestingFunc()”. Poniżej użyto funkcji „cout” i wywołano metodę main(). Następnie tworzymy wskaźnik funkcji członkowskiej.
Określamy tutaj klasę „Test” i wskaźnik funkcji składowej „*MyTestFuncPtr”. Przypisujemy „&Test::myTestingFunc” do wskaźnika funkcji składowej, który jest zadeklarowany jako „void (Test::*MyTestFuncPtr)(int)”.
Następnie generujemy obiekt klasy „t_obj” i używamy go do wywołania funkcji składowej, umieszczając obiekt klasy i używając wskaźnika „*MyTestFuncPtr”. Aby to było widoczne, gdy wywołujemy wskaźnik funkcji składowej, przypisujemy „932” jako parametr.
Kod 2:
#includeużywając przestrzeni nazw std ;
Próba klasowa {
publiczny :
próżnia myTestingFunc ( wew wartość_t ) {
cout << „Wartość testowa to” << wartość_t << koniec ;
}
} ;
wew główny ( ) {
próżnia ( Test ::* MójTestFuncPtr ) ( wew ) = & Test :: myTestingFunc ;
Przetestuj t_obj ;
( t_obj. * MójTestFuncPtr ) ( 932 ) ;
powrót 0 ;
}
Wyjście:
Wynik danego kodu jest renderowany. Widzimy, że nazwaliśmy „wskaźnik funkcji składowej” obiektem klasy, jak pokazano tutaj.
Przykład 3:
Klasa, którą generujemy w tym kodzie, to „MyNewCar”, w której używamy konstruktora „publicznego” i tworzymy w nim funkcję członkowską „startCarEngine()”. W tej funkcji dodajemy „cout”, który renderuje się, gdy wywołujemy tę funkcję w naszym kodzie. Następnie tworzymy kolejną funkcję członkowską, którą jest „stopCarEngine()” i ponownie wykorzystujemy „cout” w tej funkcji składowej.
Następnie wywołujemy funkcję main() i deklarujemy wskaźnik funkcji składowej, którym jest „MyNewCar::*carEngineFunc()”. Poniżej tworzymy obiekt klasy „MyNewCar” o nazwie „myCar_obj”. Następnie przypisujemy funkcję „startCarEngine” do wskaźnika „carEngineFunc”. Poniżej wywołujemy tę funkcję za pomocą wskaźnika „carEngineFunc”, umieszczając przy nim nazwę obiektu.
Następnie ponownie przypisujemy funkcję „stopCarEngine” do wskaźnika „carEngineFunc”. Poniżej wywołujemy tę funkcję, przekazując nazwę obiektu wraz z referencją „carEngineFunc”.
Kod 3:
#includeużywając przestrzeni nazw std ;
klasa MyNewCar {
publiczny :
próżnia uruchomCarEngine ( ) {
cout << „Silnik samochodu uruchamia się” << koniec ;
}
próżnia zatrzymajCarEngine ( ) {
cout << „Silnik samochodu się zatrzymuje” << koniec ;
}
} ;
wew główny ( ) {
próżnia ( Mój nowy samochód ::* carEngineFunc ) ( ) ;
MyNewCar myCar_obj ;
carEngineFunc = & Mój nowy samochód :: uruchomCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
carEngineFunc = & Mój nowy samochód :: zatrzymajCarEngine ;
( myCar_obj. * carEngineFunc ) ( ) ;
powrót 0 ;
}
Wyjście:
Tutaj wyświetlane jest działanie „wskaźnika funkcji składowej”. Widzimy, że utworzyliśmy wskaźnik funkcji składowej i wyświetliliśmy tutaj wynik.
Przykład 4:
Po dołączeniu pliku nagłówkowego i „std przestrzeni nazw” deklarujemy tutaj klasę „MyNewStudent”. Funkcja członkowska „studentPass()” jest jedną z funkcji składowych, które budujemy dla generowanej tutaj klasy „MyStudentClass”. Do tej funkcji dodajemy także słowo „cout”, które zostanie wygenerowane, gdy wywołamy ją w naszym kodzie.
Następnie piszemy funkcję członkowską „studentFail()”, w której ponownie używamy „cout”. Następnie wywoływana jest funkcja main() i deklarowany jest wskaźnik funkcji składowej „(MyNewStudent::*studentResultFunc)()”. Poniżej generujemy obiekt „myStd_obj” należący do klasy „MyNewStudent”.
Następnie przypisujemy funkcję „studentPass” do wskaźnika „studentResultFunc”. Poniżej wywołujemy tę funkcję, przekazując nazwę obiektu wraz z referencją „studentResultFunc”. Funkcja „studentFail” została ponownie przypisana do wskaźnika „studentResultFunc”. Poniżej wywołujemy tę metodę, podając referencję „carEngineFunc” i nazwę obiektu.
Teraz wywoływane są tutaj obie funkcje i renderowane są instrukcje zawarte w tych funkcjach.
Kod 4:
#includeużywając przestrzeni nazw std ;
klasa MójNowyStudent {
publiczny :
próżnia przepustka studencka ( ) {
cout << „Karta studencka” << koniec ;
}
próżnia studentNiepowodzenie ( ) {
cout << „Uczeń poniósł porażkę” << koniec ;
}
} ;
wew główny ( ) {
próżnia ( MójNowyStudent ::* studentWynikFun ) ( ) ;
MójNowyStudent myStd_obj ;
studentWynikFunkcja = & MójNowyStudent :: przepustka studencka ;
( myStd_obj. * studentWynikFun ) ( ) ;
studentWynikFun = & MójNowyStudent :: studentNiepowodzenie ;
( myStd_obj. * studentWynikFunkcja ) ( ) ;
powrót 0 ;
}
Wyjście:
W naszym kodzie utworzyliśmy funkcje członkowskie, a następnie wskaźnik funkcji składowej. Następnie wywołaliśmy funkcję składową i wyświetliliśmy tutaj wynik.
Przykład 5:
W tym przypadku tworzona jest klasa „SampleClass”. Następnie umieszczany jest tutaj wskaźnik funkcji składowej, czyli „(SampleClass::*MyFunc)()”. Poniżej tworzymy wskaźnik funkcji, którym jest „(*MyFuncPtr)()”. Poniżej deklarujemy „nazwę” zmiennej „string” oraz wskaźnik funkcji składowej „MyFunc f”.
Następnie mamy konstruktora „publicznego”, w którym definiujemy zmienną funkcji składowej. Poniżej tworzymy funkcje członkowskie o nazwach „myFunc_1()” i „myFunc_1()”, a także dodajemy „cout” do każdej funkcji członkowskiej, która będzie wyświetlana, gdy wywołamy tę funkcję składową.
Następnie wywołujemy ten wskaźnik funkcji członkowskiej za pomocą „(this->*f)()”. Następnie ponownie umieszczamy funkcje. Tutaj zmieniamy instrukcje „cout”, które wcześniej dodaliśmy. Następnie wywoływana jest funkcja „main()”, a wskaźnik funkcji składowej jest zdefiniowany jako „MyFunc f = &SampleClass::myFunc_2”.
Następnie wskaźnik funkcji jest również zdefiniowany jako „MyFuncPtr fp = myFunc_1”. Następnie wpisujemy „(a.*f)()”, aby wykorzystać wskaźnik funkcji składowej. „b.func” jest umieszczony w celu wykorzystania funkcji członkowskiej. Następnie umieszczamy „fp()”, aby wywołać wskaźnik funkcji.
Kod 5:
#includeużywając przestrzeni nazw std ;
klasa PróbkaKlasa ;
typedef próżnia ( PrzykładowaKlasa ::* MojaFunkcja ) ( ) ;
typedef próżnia ( * MojaFunkcjaPtr ) ( ) ;
klasa PróbkaKlasa {
nazwa ciągu ;
MyFunc f ;
publiczny :
PrzykładowaKlasa ( konst zwęglać * nazwa )
: nazwa ( nazwa ) ,
F ( & PrzykładowaKlasa :: mojaFunkcja_1 )
{ }
próżnia mojaFunkcja_1 ( ) { cout << nazwa << „Wywołaliśmy tutaj funkcję 1” << koniec ; }
próżnia mojaFunkcja_2 ( ) { cout << nazwa << „Wywołaliśmy tutaj funkcję 2” << koniec ; }
próżnia funk ( ) {
( Ten ->* F ) ( ) ;
}
} ;
próżnia mojaFunkcja_1 ( ) { cout << „Pierwsza funkcja” << koniec ; }
próżnia mojaFunkcja_2 ( ) { cout << „Druga funkcja” << koniec ; }
wew główny ( )
{
MyFunc f = & PrzykładowaKlasa :: mojaFunkcja_2 ;
MyFuncPtr fp = mojaFunkcja_1 ;
Przykładowa klasa a ( 'Pierwszy - ' ) , B ( 'drugi - ' ) ;
( A. * F ) ( ) ;
B. funk ( ) ;
fp ( ) ;
}
Wyjście:
Wynik kodu jest teraz renderowany tutaj, co odpowiednio renderuje wynik, tak jak nazywaliśmy funkcje w naszym kodzie.
Wniosek
Zbadaliśmy, że „wskaźniki funkcji składowych” w C++ ułatwiają dynamiczne wiązanie, hermetyzację zachowania i elastyczną obsługę wywoływania funkcji w kontekście OOP. Dowiedzieliśmy się, że użycie „wskaźników funkcji składowych” może znacznie poprawić modułowość i elastyczność baz kodu C++, zapewniając potężne narzędzie do rozwiązywania licznych wyzwań projektowych i wykonawczych.