Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00165 013866 11052061 na godz. na dobę w sumie
C++Builder 6. Ćwiczenia zaawansowane - książka
C++Builder 6. Ćwiczenia zaawansowane - książka
Autor: Liczba stron: 140
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-089-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ builder - programowanie
Porównaj ceny (książka, ebook, audiobook).
Jeśli opanowałeś już podstawy C++ Buildera i zacząłeś wykorzystywać to środowisko we własnych projektach, przyszedł zapewne czas na dokonanie następnego kroku: poznanie zaawansowanych technik programistycznych.

Książka 'C++Builder 6. Ćwiczenia zaawansowane' to ponad 30 kompletnych przykładowych projektów. Jak wszystkie książki z tej serii jest ona skierowana do praktyków: nie znajdziesz więc w niej rozważań teoretycznych, za to w krótkim czasie, krok po kroku, opanujesz C++ Buildera na profesjonalnym poziomie. Także użytkownicy innych środowisk programistycznych wykorzystujących język C++ skorzystają na jej lekturze.

Opisano między innymi:

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

C++Builder 6. Æwiczenia zaawansowane Autor: Andrzej Daniluk ISBN: 83-7361-089-8 Format: B5, stron: 138 Jeġli opanowa³eġ ju¿ podstawy C++ Buildera i zacz¹³eġ wykorzystywaæ to ġrodowisko we w³asnych projektach, przyszed³ zapewne czas na dokonanie nastêpnego kroku: poznanie zaawansowanych technik programistycznych. Ksi¹¿ka „C++Builder 6. Æwiczenia zaawansowane” to ponad 30 kompletnych przyk³adowych projektów. Jak wszystkie ksi¹¿ki z tej serii jest ona skierowana do praktyków: nie znajdziesz wiêc w niej rozwa¿añ teoretycznych, za to w krótkim czasie, krok po kroku, opanujesz C++ Buildera na profesjonalnym poziomie. Tak¿e u¿ytkownicy innych ġrodowisk programistycznych wykorzystuj¹cych jêzyk C++ skorzystaj¹ na jej lekturze. Opisano miêdzy innymi: • Wskazania, adresy i odwo³ania • Prze³adowywanie operatorów • Funkcje wirtualne, klasy pochodne, polimorficzne i abstrakcyjne • Wykorzystanie w¹tków i procesów • Operacje na plikach • Modyfikowanie typów zmiennych w czasie wykonywania programu • Generowanie liczb pseudolosowych • Wykorzystanie koprocesora matematycznego • Tworzenie nowych komponentów C++ Buildera i modyfikowanie istniej¹cych IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Spis treści Wstęp..............................................z...................................................z..........................................................5 Rozdział 1. Wskazania i adresy...................................................z.............................................................................7 Organizacja pamięci w komputerze................................................... ................................. 7 Operatory wskaźnikowe................................................... ................................................. 9 Wskaźniki i tablice ................................................... ................................................... ..... 9 Wskaźniki ze słowem kluczowym const ................................................... ........................ 13 Wielokrotne operacje pośrednie................................................... .................................... 14 Wskaźniki do funkcji................................................... ................................................... 15 Wskaźniki i pamięć alokowana dynamicznie ................................................... ................. 20 Stos................................................... ................................................... ................... 21 Sterta................................................... ................................................... ................. 22 Dereferencja wskaźnika ................................................... ............................................... 27 Operatory (.*) oraz (- *) ................................................... ............................................. 29 Podsumowanie................................................... ................................................... ......... 30 Rozdział 2. Odwołania...................................................z...................................................z..........................................31 Czym są odwołania?................................................... ................................................... . 31 Parametry odwołaniowe................................................... ............................................... 33 Zwracanie odwołań przez funkcje................................................... ................................. 35 Odwołania do struktur ................................................... ................................................. 36 Podsumowanie................................................... ................................................... ......... 38 Rozdział 3. Przeładowywanie operatorów...................................................z...................................................39 Przeładowywanie jednoargumentowych operatorów + + oraz – – ....................................... 40 Przeładowywanie operatorów (!) oraz (!=) ................................................... .................... 43 Przeładowywanie operatora ................................................... ...................................... 46 Przeładowywanie operatora indeksowania tablic []................................................... ......... 47 Podsumowanie................................................... ................................................... ......... 50 Rozdział 4. Tablice jako urządzenia wejścia-wyjścia...................................................z.............................51 Podsumowanie................................................... ................................................... ......... 54 Rozdział 5. Funkcje wirtualne. Klasy pochodne, polimorficzne i abstrakcyjne............................55 Odwołania i wskaźniki do klas pochodnych................................................... ................... 55 Funkcje wirtualne w C++................................................... ............................................. 58 Funkcje wirtualne w C++Builderze................................................... ............................... 61 Klasy abstrakcyjne w stylu biblioteki VCL ................................................... .................... 64 Podsumowanie................................................... ................................................... ......... 66 4 C++Builder 6. Ćwiczenia zaawansowane Rozdział 6. Typy danych Windows...................................................z....................................................................67 Rozdział 7. Wątki...................................................z...................................................z...................................................69 Wątki i procesy ................................................... ................................................... ........ 69 Funkcja _beginthread() ................................................... ................................................ 70 Funkcja _beginthreadNT() ................................................... ........................................... 72 Funkcja BeginThread() ................................................... ................................................ 77 Zmienne lokalne wątku................................................... ................................................ 80 Klasa TThread ................................................... ................................................... ......... 81 Metody................................................... ................................................... .............. 81 Właściwości................................................... ................................................... ....... 82 Podsumowanie................................................... ................................................... ......... 84 Rozdział 8. Operacje na plikach ...................................................z.......................................................................85 Moduł SysUtils ................................................... ................................................... ........ 85 Windows API ................................................... ................................................... .......... 91 Klasa TMemoryStream.................................................. ................................................. 98 Podsumowanie................................................... ................................................... ....... 101 Rozdział 9. Zmienne o typie modyfikowalnym w czasie wykonywania programu ....................103 Struktura TVarData ................................................... ................................................... 103 Klasa TCustomVariantType ................................................... ....................................... 105 Moduł Variants ................................................... ................................................... ...... 107 Tablice wariantowe ................................................... ................................................... 109 Podsumowanie................................................... ................................................... ....... 113 Rozdział 10. Liczby pseudolosowe...................................................z....................................................................115 Losowanie z powtórzeniami ................................................... ....................................... 116 Losowanie bez powtórzeń................................................... .......................................... 119 Podsumowanie................................................... ................................................... ....... 124 Rozdział 11. Funkcje FPU...................................................z...................................................z....................................125 Podsumowanie................................................... ................................................... ....... 128 Rozdział 12. Komponentowy model C++Buildera ...................................................z....................................129 Tworzymy nowy komponent.................................................. ....................................... 129 Modyfikacja istniejącego komponentu z biblioteki VCL/CLX.......................................... 135 Podsumowanie................................................... ................................................... ....... 138 Rozdział 3. Przeładowywanie operatorów Język C++ udostępnia programistom niezwykle wydajne narzędzie w postaci możliwo- ści przeładowywania (określania nowych działań) wybranych operatorów. Przeładowywanie (przedefiniowywanie) operatorów umożliwia rozszerzenie obszaru zastosowań wybranego operatora na elementy niezdefiniowanej wcześniej unikalnej klasy. Projektując algorytm nowego działania wybranego operatora, należy skorzystać ze spe- cjalnej funkcji o zastrzeżonej nazwie QRGTCVQT: QRGTCVQTU[ODQNQRGTCVQTC RCTCOGVT[ QRELQPCNPK[G  ] KPUVTWMELG _ Zapis ten oznacza, iż, na przykład, najprostsza funkcja opisująca nowy algorytm odejmowa- nia (nowy sposób działania unarnego operatora odejmowania Ō) będzie mogła przybrać następującą postać: QRGTCVQTŌ RCTCOGVT[ ]KPUVTWMELG_ Reguły C++ umożliwiają przeładowywanie praktycznie wszystkich operatorów, za wy- jątkiem czterech, dla których nie jest możliwe zdefiniowanie nowych działań: (cid:1)  operatora kropki umożliwiającego uzyskiwanie bezpośredniego dostępu do pół struktur i klas, (cid:1)  operatora wskazującego wybrany element klasy, (cid:1)  operatora rozróżniania zakresu, (cid:1) ! operatora warunkowego. 40 C++Builder 6. Ćwiczenia zaawansowane Przeładowywanie jednoargumentowych operatorów ++ oraz –– Jako przykład praktycznego wykorzystania przeładowanego operatora postinkrementacji posłuży nam sytuacja zliczania elementów ciągu znaków wprowadzonych z klawiatury. W celu przeładowania jednoargumentowego operatora w pierwszej kolejności musimy zaprojektować odpowiednią funkcję operatorową. Każda funkcja operatorowa powinna mieć możliwość wykonywania odpowiednich operacji na właściwych egzemplarzach klasy (lub obiektu), inaczej mówiąc, powinna w stosunku do odpowiedniej klasy posiadać status funkcji zaprzyjaźnionej lub być normalną metodą w klasie. Zaprojektujemy prostą klasę o nazwie EQWPVGT (licznik): ENCUUEQWPVGT ] RWDNKE KPVPWODGT EQWPVGT ]VJKU PWODGT_ EQWPVGTQRGTCVQT ]VJKU PWODGT TGVWTP VJK[U _ _CFF Ponieważ celem naszym będzie zwiększanie w odpowiedni sposób (postinkrementowanie) wartości pola PWODGT egzemplarza CFF klasy EQWPVGT, funkcja operatorowa przybierze nieskomplikowaną postać: EQWPVGTQRGTCVQT ]VJKU PWODGT TGVWTP VJKU _[ Zauważmy, iż funkcja ta, będąc normalną metodą w klasie, nie posiada jawnych argu- mentów i w momencie wywołania otrzymuje niejawny wskaźnik VJKU do własnego eg- zemplarza klasy. Dzięki posiadaniu niejawnego wskaźnika VJKU funkcja ma możliwość postinkrementowania wartości pola PWODGT własnego egzemplarza klasy. Dzięki instrukcji: TGVWTP VJKU funkcja operatorowa jawnie zwraca wskaźnik do zmodyfikowanego egzemplarza CFF klasy EQWPVGT. Ćwiczenie 3.1. Każda funkcja składowa klasy otrzymuje niejawnie argument w postaci wskaźnika do obiektu, który ją wywołał, i do którego uzyskuje się dostęp, wykorzystując słowo kluczowe (wskaźnik) VJKU. Funkcje składowe przeładowywanych operatorów jednoargumentowych nie potrzebują żadnych jawnie zadeklarowanych parametrów formalnych. Jedynym argu- mentem, którego należy użyć, jest wskaźnik VJKU, będący w rzeczywistości wskaźnikiem do egzemplarza klasy, a nie jego kopią. Konsekwencją tego jest fakt, iż wszystkie modyfi- kacje wykonane za jego pośrednictwem przez funkcję operatora modyfikują zawartość wywoływanego egzemplarza klasy. Przykład wykorzystania funkcji QRGTCVQT prze- ładowanego operatora w celu zliczania znaków wprowadzanych z klawiatury zamiesz- czono na listingu 3.1. Koniec ciągu wprowadzanych znaków oznaczamy klawiszem Esc. Rozdział 3. (cid:1) Przeładowywanie operatorów 41 Listing 3.1. Główny moduł Unit_13.cpp projektu Projekt_13.bpr wykorzystującego normalną funkcję składową przeładowanego operatora jednoargumentowego ++. W przedstawionym algorytmie zrezygnowano z używania niejawnych wskaźników this KPENWFGKQUVTGCOJ KPENWFGEQPKQJ RTCIOCJFTUVQR ENCUUEQWPVGT ] RWDNKE KPVPWODGT EQWPVGT ]PWODGT_ EQWPVGTQRGTCVQT RQUVKPMTGOGPVCELCRQNCPWODGT ]PWODGT TGVWTP VJKU _ _CFF [ KPVOCKP ] EJCTEJ EQWV2QFCLKOKúKPCYKUMQ #D[CMQēE[èPCEKħPKL= UE?K= PVGT?GPFN YJKNG  ] EKP EJ KH EJZ$ DTGCM NKECPKGPCMÎYOGVQFæRTGKPMTGOGPVCELK  CFF _ EQWV9RTQYCFQPQCFFPWODGTPCMK PCMÎY  IGVEJ  TGVWTP _ Analizując powyższe zapisy, warto zwrócić uwagę na pewien szczegół. Mianowicie jawny wskaźnik VJKU wskazuje własny obiekt funkcji. Jeżeli jednak zażądamy, aby funkcja uzyskiwała dostęp nie do pola własnego egzemplarza klasy, ale do pola obiektu przeka- zywanego jej jako argument, zawsze możemy nadać jej status HTKGPF, czyli funkcji za- przyjaźnionej. Funkcje z nadanym statusem HTKGPF będą bez problemu uzyskiwać dostęp do pól klasy, nie będąc przy tym traktowane jako zwykłe metody w klasie. Ćwiczenie 3.2. Proces przeładowywania operatorów jednoargumentowych może przebiegać z wykorzy- staniem funkcji zaprzyjaźnionych (ang. friend functions). Należy jednak zwrócić uwagę, iż stosując taką technikę przeładowywania operatorów powinniśmy w odpowiedni sposób używać parametrów odwołaniowych po to, aby kompilator przekazywał funkcji opera- tora adres, a nie kopię egzemplarza klasy, który ją wywołał, umożliwiając zmianę jego zawartości. W przeciwieństwie do normalnych funkcji składowych funkcje zaprzyjaźnione nie mogą otrzymywać wskaźnika VJKU (niezależnie od tego, czy traktowany będzie jako wskaźnik jawny czy niejawny), co powoduje, iż nie są w stanie określić wywołującego je egzemplarza klasy, tak jak pokazano to na listingu 3.2. 42 C++Builder 6. Ćwiczenia zaawansowane Listing 3.2. Zmodyfikowany kod głównego modułu projektu Projekt_13.bpr wykorzystującego zaprzyjaźnioną funkcję operator ++() kategorii friend przeładowanego operatora jednoargumentowego (++) KPENWFGKQUVTGCOJ KPENWFGEQPKQJ RTCIOCJFTUVQR ENCUUEQWPVGT ] RWDNKE KPVZ RCTCOGVTQFYQđCPKQY[PWODGTWOQľNKYKCRTGđCFQYCPKG QRGTCVQTC HTKGPFEQWPVGTQRGTCVQT EQWPVGTPWODGT RQUVKPMTGOGPVCELKRQFNGICRQNGZ GIGORNCTCCFFMNCU[EQWPVGT ]PWODGTZ TGVWTP PWODGT _ _CFF [ KPVOCKP ] EJCTEJ EQWV2QFCLKOKúKPCYKUMQ #D[CMQēE[èPCEKħPKL= UE?K= PVGT?GPFN YJKNG  ] EKP EJ KH EJZ$ DTGCM  CFF _ EQWV9RTQYCFQPQCFFZPCMK PCMÎY  IGVEJ  TGVWTP _ Postępując zgodnie z regułami języka C++, zalecane jest, aby operatory przeładowywać za pomocą zwykłych funkcji składowych. Możliwość korzystania z funkcji zaprzyjaźnionych została wprowadzona głównie w celu rozwiązywania bardziej skomplikowanych i nietypowych problemów związanych z przeładowywaniem operatorów. Ćwiczenie 3.3. Wykorzystując samodzielnie zaprojektowaną normalną funkcję składową, przeładuj jedno- argumentowy operator postdekrementacji (). Ćwiczenie 3.4. Wykorzystując samodzielnie zaprojektowaną funkcję kategorii HTKGPF przeładuj jedno- argumentowy operator postdekrementacji (). Rozdział 3. (cid:1) Przeładowywanie operatorów 43 Przeładowywanie operatorów (!) oraz (!=) W trakcie pisania programów bardzo często stajemy przez problemem zaprojektowania algorytmów wykonujących określone działania matematyczne. C++ udostępnia szereg operatorów oraz funkcji bibliotecznych, którymi możemy się zawsze posłużyć. Jednak wiele praktycznie użytecznych działań nie doczekało się gotowej postaci funkcyjnej lub operatorowej. Jednym z przykładów ilustrującym to zagadnienie jest problem obliczania silni (ang. factorial) wybranej liczby: P    P  np.:      Operator negacji logicznej () bardzo dobrze nadaje się do tego, aby stać się symbolem nowego działania polegającego na obliczaniu silni nieujemnej liczby całkowitej. Ćwiczenie 3.5. W celu określenia nowego rodzaju działania dla operatora () posłużymy się jednoar- gumentową funkcją operatorową QRGTCVQT kategorii HTKGPF. Funkcja ta, typu XQKF, nie powinna zwracać żadnej wartości, gdyż jedynym jej celem będzie obliczenie silni wybranej liczby PWODGT będącej jej argumentem formalnym. Zgodnie z podstawowymi regułami matematyki silnię możemy wyliczyć jedynie dla nieujemnej liczby całkowitej. Aby zapobiec przykrym niespodziankom mogącym wystąpić w trakcie działania pro- gramu i związanym z błędnie wprowadzonym z klawiatury argumentem aktualnym P funkcji obliczającej silnię — przed wywołaniem funkcji przeładowanego operatora () zastosujemy blok instrukcji VT[VJTQYECVEJ przechwytującej odpowiedni wyjątek. Listing 3.3. Kod głównego modułu projektu Projekt_14.bpr wykorzystującego jednoargumentową zaprzyjaźnioną funkcję kategorii friend przeładowanego operatora jednoargumentowego (!) KPENWFGKQUVTGCOJ KPENWFGEQPKQJ RTCIOCJFTUVQR ENCUUHCEVQTKCNUKNPKC ] RWDNKE WPUKIPGFKPVXCNWG HCEVQTKCN WPUKIPGFKPVP ]XCNWGP_ HTKGPFXQKFQRGTCVQT HCEVQTKCN  _ [ XQKFQRGTCVQT HCEVQTKCNPWODGT ] WPUKIPGFKPVTGUWNV HQT WPUKIPGFKPVKKPWODGTXCNWGK TGUWNV K 44 C++Builder 6. Ćwiczenia zaawansowane KH TGUWNV EQWVRTGMTQEQP[CMTGUNKEDWPUKIPGFKPV GNUG EQWVTGUWNV TGVWTP _ [ KPVOCKP ] KPVP EQWV2QFCLNKEDú VT[ ] EKP P KH P PKGRTCYKFđQY[CTIWOGPVFNC HWPMELKQRGTCVQT VJTQY P  _ ECVEJ WPUKIPGFKPVP ]_ HCEVQTKCNHCEVQTKCNAP P  EQWVP HCEVQTKCNAP IGVEJ  TGVWTP _ Ćwiczenie 3.6. Testując algorytm z poprzedniego ćwiczenia, ktoś dociekliwy na pewno spróbuje wy- wołać funkcję operatora () zgodnie z tradycyjnym matematycznym zapisem: HCEVQTKCNAP Wywołanie takie będzie dla kompilatora C++ niezrozumiałe z tego powodu, iż potraktuje je jako „niedokończone” i będzie oczekiwał, że pomiędzy znakiem () oraz znakiem końca instrukcji () powinien znajdować się jeszcze jakiś symbol. Należy oczekiwać, iż symbolem tym będzie znak przypisania (). Jeżeli więc zdecydujemy się używać w pro- gramie funkcji przeładowanego operatora zgodnie z intuicyjnym rozumieniem symbolu silni powinniśmy w pewien sposób oszukać kompilator: HCEVQTKCNAPHCEVQTKCNAP Otóż funkcja QRGTCVQT przeładowanego operatora  powinna być dwuargumentowa (gdyż tradycyjnie traktowany operator relacji  jest w rzeczywistości dwuargumentowy). Do obliczenia silni pojedynczej liczby drugi argument nie jest potrzebny, z tego względu bez większych wyrzutów sumienia dwuargumentową funkcję operatorową przeładowanego operatora  możemy zapisać w ten sposób, aby jej drugi argument UGGOKPI był argu- mentem pozornym (tzn. argumentem wymaganym przez składnię języka, ale w programie nie odgrywającym żadnej roli). Rozdział 3. (cid:1) Przeładowywanie operatorów 45 Listing 3.4. Kod głównego modułu zmodyfikowanego projektu Projekt_14.bpr wykorzystującego dwuargumentową zaprzyjaźnioną funkcję kategorii friend przeładowanego operatora dwuargumentowego (!=). Pierwszy argument funkcji jest argumentem rzeczywistym, drugi pozornym KPENWFGKQUVTGCOJ KPENWFGEQPKQJ RTCIOCJFTUVQR ENCUUHCEVQTKCN ] RWDNKE WPUKIPGFKPVXCNWG HCEVQTKCN WPUKIPGFKPVPWPUKIPGFKPVU ]XCNWG[P_ HTKGPFXQKFQRGTCVQT HCEVQTKCNHCEVQTKCN  _ [ XQKFQRGTCVQT HCEVQTKCNPWODGTHCEVQTKCNUGGOKPI RQQ[TP[  ] WPUKIPGFKPVTGUWNV HQT WPUKIPGFKPVKKPWODGTXCNWGK TGUWNV K KH TGUWNV EQWVRTGMTQEQP[CMTGUNKEDWPUKIPGFKPV GNUG EQWVTGUWNV TGVWTP _ [ KPVOCKP ] KPVPU ULCMQRCTCOGVTRQQTP[OWUKD[èCFGMNCTQYCP[CN[G YRTQITCOKGPKGQVT[OWLGľCFPGLYCTVQħEK EQWV2QFCLNKEDú VT[ ] EKP P KH P PKGRTCYKFđQY[CTIWOGPVFNC HWPMELKQRGTCVQTC UKNPKC VJTQY P  _ ECVEJ WPUKIPGFKPVP ]_ HCEVQTKCNHCEVQTKCNAP PU  EQWVP HCEVQTKCNAPHCEVQTKCNAP IGVEJ  TGVWTP _ Ćwiczenie 3.7. Samodzielnie zaprojektuj dowolną metodę przeładowywania dwuargumentowych ope- ratorów unarnych ( ) oraz (Ō) 46 C++Builder 6. Ćwiczenia zaawansowane Przeładowywanie operatora Jak zapewne wiemy,  może być używany jako operator jednoargumentowy — występuje wówczas w programie w roli operatora adresowego (por. ćwiczenie 1.2) lub może być operatorem dwuargumentowym — wtedy odgrywa rolę operatora bitowej koniunkcji. W niniejszym podrozdziale jednoargumentowy operator przeładujemy tak, aby, używając go w odpowiedni sposób, możliwym było odczytanie wartości wybranego elementu jedno- wymiarowej tablicy. Ćwiczenie 3.8. W celu odpowiedniego przeładowania operatora  skonstruujemy nową klasę CTTC[. Funkcję operatorową potraktujemy jako funkcję zaprzyjaźnioną po to, aby mogła uzy- skiwać dostęp do wszystkich pół egzemplarza swojej klasy, tak jak pokazano to na li- stingu 3.5. W wyniku działania programu powinniśmy bez trudu odczytać w odwrotnej kolejności wartości elementów tablicy VCD oraz wykonać na nich wybrane działanie aryt- metyczne. Listing 3.5. Kod głównego modułu Unit_15.cpp projektu Projekt_15.bpr wykorzystującego jednoargumentową zaprzyjaźnioną funkcję przeładowanego jednoargumentowego operatora KPENWFGKQUVTGCOJ KPENWFGEQPKQJ KPENWFGU[UVGOJRR RTCIOCJFTUVQR ENCUUCTTC[ ] KPVVCDNKEC RWDNKE HTKGPFKPVQRGTCVQT CTTC[PWODGT ]TGVWTP PWODGTVCDNKEC _ _ [ KPVOCKP ] CTTC[VCD=?]_ Y[ħYKGVNCPKGGNGOGPVÎYVCDNKE[YQFYTQVPGLMQNGLPQħ[EK HQT KPVK#44#;5+ VCD ŌK KŌŌ EQWVVCD=K?GPFN EQWVVCD=? VCD=?VCD=? VCD=? IGVEJ  TGVWTP _ Testując algorytm funkcji przeładowanego operatora,  możemy samodzielnie stwier- dzić, iż powtórne wykorzystanie jednoargumentowego operatora adresowego  w celu pobrania adresów poszczególnych elementów zainicjowanej odpowiednimi wartościami tablicy VCD z oczywistych względów okaże się czynnością niemożliwą do zrealizowania. Wynika to z faktu, iż tablica VCD w istocie została zadeklarowana w funkcji OCKP jako pewien obiekt klasy CTTC[, w której uprzednio zdefiniowano już jednoargumentową funkcję QRGTCVQT przeładowanego operatora . Rozdział 3. (cid:1) Przeładowywanie operatorów 47 Przeładowywanie operatora indeksowania tablic [] Operator indeksowania tablic =? podczas przedefiniowywania traktowany jest jako ope- rator dwuargumentowy i z powodzeniem może być przeładowany za pomocą funkcji składowej klasy bez potrzeby posługiwania się funkcją zaprzyjaźnioną. Ćwiczenie 3.9. Jako praktyczny przykład wykorzystania funkcji QRGTCVQT=?= przeładowanego ope- ratora =? rozpatrzmy prostą klasę CTTC[, w której zadeklarowano jednowymiarową tablicę VCDNKEC o pięciu elementach typu FQWDNG. Konstruktor CTTC[ przypisuje każdemu z jej elementów odpowiednią wartość początkową. ENCUUCTTC[ ] FQWDNGVCDNKEC=? RWDNKE MQPUVTWMVQT CTTC[ FQWDNGKFQWDNGLFQWDNGMFQWDNGNFQWDNG[O ] VCDNKEC=?K VCDNKEC=?L VCDNKEC=?M VCDNKEC=?N VCDNKEC=?O _ Wartością powrotną funkcji przeładowanego operatora =? jest wartość elementu tablicy o numerze (indeksie) jednoznacznie określonym poprzez argument funkcji: FQWDNGQRGTCVQT=? KPVK ]TGVWTPVCDNKEC=K?_ Na listingu 3.6 pokazano praktyczny przykład zastosowania w programie omawianych funkcji. Listing 3.6. Kod głównego modułu Unit_16.cpp projektu Projekt_16.bpr wykorzystującego jednoargumentową funkcję składową przeładowanego operatora [] KPENWFGKQUVTGCOJ KPENWFGEQPKQJ KPENWFGU[UVGOJRR RTCIOCJFTUVQR ENCUUCTTC[ ] FQWDNGVCDNKEC=? RWDNKE MQPUVTWMVQT 48 C++Builder 6. Ćwiczenia zaawansowane CTTC[ FQWDNGKFQWDNGLFQWDNGMFQWDNGNFQWDNG[O ] VCDNKEC=?K VCDNKEC=?L VCDNKEC=?M VCDNKEC=?N VCDNKEC=?O _ FQWDNGQRGTCVQT=? KPVK ]TGVWTPVCDNKEC=K?_ _ [ KPVOCKP ] CTTC[VCD   HQT KPVKK#44#;5+ VCD K EQWVVCD=K?GPFN IGVEJ  TGVWTP _ Ćwiczenie 3.10. Pokazaną w poprzednim ćwiczeniu funkcję przeładowanego operatora =? można zdefi- niować również w ten sposób, aby operator =? mógł być używany zarówno po lewej, jak i po prawej stronie instrukcji przypisania. W tym celu wystarczy zastosować typ odwoła- niowy wartości powrotnej funkcji QRGTCVQT=? : FQWDNGQRGTCVQT=? KPVK  Zapis taki spowoduje, iż funkcja zwracać będzie teraz odwołanie do elementu tablicy o in- deksie K. Skutkiem tego umieszczenie wartości funkcji po lewej stronie instrukcji przy- pisania spowoduje zmodyfikowanie określonego elementu tablicy, tak jak pokazano to na listingu 3.7. Śledząc poniższy listing, warto zwrócić uwagę na sposób określania błędu przekroczenia dopuszczalnego zakresu tablicy VCDNKEC. Dzięki zastosowaniu prostego bloku instrukcji VT[ŗVJTQYŗECVEJ, funkcja operatorowa: FQWDNGCTTC[QRGTCVQT=? KPVK ] VT[ ] KH K  VJTQY VCDNKEC=K?  _ ECVEJ FQWDNGVCDNKEC ]_ TGVWTPVCDNKEC=K? _ bez trudu wykrywa błąd przekroczenia zakresu tablicy, co skutkuje wygenerowaniem stosownego wyjątku informującego o próbie przypisania nieodpowiedniego miejsca pamięci, czyli błędu naruszenia pamięci. Rozdział 3. (cid:1) Przeładowywanie operatorów 49 Listing 3.7. Kod głównego modułu Unit_17.cpp projektu Projekt_17.bpr wykorzystującego jednoargumentową funkcję składową przeładowanego operatora []. Funkcja operatorowa operator[]() zwraca wartość powrotną poprzez odwołanie KPENWFGKQUVTGCOJ KPENWFGEQPKQJ KPENWFGU[UVGOJRR RTCIOCJFTUVQR ENCUUCTTC[ ] FQWDNGVCDNKEC=? RWDNKE CTTC[ FQWDNGKFQWDNGLFQWDNGMFQWDNGNFQWDNG[O ] VCDNKEC=?K VCDNKEC=?L VCDNKEC=?M VCDNKEC=?N VCDNKEC=?O _ HWPMELCQRGTCVQTQYCYTCECYCTVQħèRQYTQVPæ RQRTGQFYQđCPKG FQWDNGQRGTCVQT=? KPVK  _ URTCYFCCMTGUVCDNKE[MNCU[CTTC[ FQWDNGCTTC[QRGTCVQT=? KPVK ] VT[ ] KH K  VJTQY VCDNKEC=K?  _ ECVEJ FQWDNGVCDNKEC ]_ TGVWTPVCDNKEC=K? _ [ KPVOCKP ] CTTC[VCD   HQT KPVKK#44#;5+ VCD K EQWVVCD=K?GPFN EQWVGPFN RTGđCFQYCP[QRGTCVQT=? RQNGYGLUVTQPKGPCMWRT[RKUCPKC VCD=? VCD=? VCD=? VCD=? VCD=? HQT KPVKK#44#;5+ VCD K EQWVVCD=K?GPFN IGVEJ  TGVWTP _ 50 Ćwiczenie 3.11. C++Builder 6. Ćwiczenia zaawansowane Zmodyfikuj funkcję QRGTCVQT=? w ten sposób, aby w przypadku wykrycia błędu prze- kroczenia zakresu tablicy powstałego w wyniku błędnego przypisania typu: VCD=? program został bezpiecznie zakończony, nie generując przy tym wyjątku informującego o błędzie naruszenia pamięci. Podsumowanie Możliwość swobodnego przedefiniowywania istniejących operatorów jest jedną z wielkich zalet obiektowego języka C++. Rozsądne posługiwanie się samodzielnie przeładowanymi operatorami w wielu przypadkach może znacznie uprościć kod tworzonego programu i spowodować, iż stanie się ona bardziej czytelny dla osób, które będą się nim opiekować w dalszej perspektywie czasu.
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C++Builder 6. Ćwiczenia zaawansowane
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: