Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00093 007772 10476493 na godz. na dobę w sumie
C++Builder Borland Developer Studio 2006. Kompendium programisty - książka
C++Builder Borland Developer Studio 2006. Kompendium programisty - książka
Autor: Liczba stron: 744
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0494-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).

Jeden z najnowszych produktów firmy Borland, C++Builder Borland Developer Studio 2006, to połączenie nowoczesnego języka programowania, jakim jest C++, biblioteki komponentów wizualnych, zintegrowanego środowiska programistycznego oraz narzędzi służących do modelowania oprogramowania. Pomimo że zaimplementowana w C++Builder wersja języka C++ nie jest dokładnym odzwierciedleniem standardu ANSI, środowisko to zyskało duże uznanie wśród najlepszych programistów, doceniających jego uniwersalność i stabilność.

Książka 'C++Builder Borland Developer Studio 2006. Kompendium programisty' przedstawia zasady programowania w języku C++ z wykorzystaniem narzędzia C++Builder 2006. Opisuje zarówno samo środowisko, jak i poszczególne elementy języka. Dzięki niej nauczysz się korzystać z języka UML używanego do projektowania aplikacji oraz dowiesz się, jak realizować projekty, wykorzystując język C++. Poznasz także nowoczesne metodologie tworzenia oprogramowania za pomocą narzędzi typu RAD.

Poznaj potęgę języka C++
i zdobądź szczególne umiejętności programowania.

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

Darmowy fragment publikacji:

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 C++Builder Borland Developer Studio 2006. Kompendium programisty Autor: Andrzej Daniluk ISBN: 83-246-0494-4 Format: B5, stron: 744 Jeden z najnowszych produktów firmy Borland, C++Builder Borland Developer Studio 2006, to po³¹czenie nowoczesnego jêzyka programowania, jakim jest C++, biblioteki komponentów wizualnych, zintegrowanego œrodowiska programistycznego oraz narzêdzi s³u¿¹cych do modelowania oprogramowania. Pomimo ¿e zaimplementowana w C++Builder wersja jêzyka C++ nie jest dok³adnym odzwierciedleniem standardu ANSI, œrodowisko to zyska³o du¿e uznanie wœród najlepszych programistów, doceniaj¹cych jego uniwersalnoœæ i stabilnoœæ. Ksi¹¿ka „C++Builder Borland Developer Studio 2006. Kompendium programisty” przedstawia zasady programowania w jêzyku C++ z wykorzystaniem narzêdzia C++Builder 2006. Opisuje zarówno samo œrodowisko, jak i poszczególne elementy jêzyka. Dziêki niej nauczysz siê korzystaæ z jêzyka UML u¿ywanego do projektowania aplikacji oraz dowiesz siê, jak realizowaæ projekty, wykorzystuj¹c jêzyk C++. Poznasz tak¿e nowoczesne metodologie tworzenia oprogramowania za pomoc¹ narzêdzi typu RAD. (cid:129) œrodowisko C++Builder Borland Developer Studio 2006 (cid:129) Podstawy jêzyka UML (cid:129) Korzystanie z biblioteki STL (cid:129) Obs³uga wyj¹tków (cid:129) Operacje na systemie plików (cid:129) Programowanie wielow¹tkowe (cid:129) Komponenty (cid:129) Programowanie grafiki Poznaj potêgê jêzyka C++ i zdob¹dŸ szczególne umiejêtnoœci programowania Wstęp ................................................................................................................................................................11 Rozdział 1. Rozdział 2. Środowisko programisty IDE C++Builder Borland Developer Studio 2006 ..................... 15 Struktura głównego menu ................................................................................................18 Pasek narzędzi — Speed Bar ...........................................................................................47 Inspektor obiektów — Object Inspector ....................................................................48 Widok struktury obiektów .........................................................................................49 Ogólna postać programu pisanego w C++ .......................................................................50 Funkcja main() ...........................................................................................................52 Dyrektywa #include i prekompilacja .........................................................................53 Konsolidacja ..............................................................................................................54 Konfiguracja opcji projektu .......................................................................................54 Uruchamiamy program ..............................................................................................57 Ogólna postać programu pisanego w C++Builderze BDS 2006 ......................................58 Formularz ...................................................................................................................59 Zdarzenia ....................................................................................................................61 Konsola czy formularz? ...................................................................................................64 Podsumowanie .................................................................................................................64 Język modelowania, model dojrzałości i proces projektowania ...............................................65 UML jako język modelowania .........................................................................................65 Zawartość UML ...............................................................................................................67 Diagramy klas ............................................................................................................67 Diagramy obiektów ....................................................................................................72 Diagramy komponentów ............................................................................................73 Diagramy elementów zawierających strukturę wewnętrzną ......................................74 Diagramy pakietów ....................................................................................................75 Diagramy wdrożenia ..................................................................................................76 Diagramy czynności ...................................................................................................76 Diagramy przypadków użycia ...................................................................................79 Diagramy stanów .......................................................................................................80 Diagramy przebiegu ...................................................................................................82 D:Roboczy Jarekmakiety poprawki programisty\_Spis treści.doc (29-05-06/14:06) i druku pdfC++Builder Borland Developer Studio 2006. Kompendium 3 4 C++Builder Borland Developer Studio 2006. Kompendium programisty Rozdział 3. Diagramy współpracy ................................................................................................84 Diagramy komunikacji ...............................................................................................84 Diagramy harmonogramowania zadań ......................................................................85 Mechanizmy rozszerzania ..........................................................................................85 Strategia modelowania i dokumentowania ......................................................................87 Model dojrzałości .............................................................................................................88 Proces projektowania .......................................................................................................88 Nie tylko IID ..............................................................................................................90 Podsumowanie .................................................................................................................90 Podstawy języka C++ ...............................................................................................................................91 Dyrektywy preprocesora ..................................................................................................91 Dyrektywa #include ...................................................................................................91 Dyrektywa #define .....................................................................................................92 Dyrektywa #undef ......................................................................................................92 Dyrektywa #pragma hdrstop ......................................................................................92 Dyrektywa #pragma argsused ....................................................................................92 Dyrektywa #pragma inline .........................................................................................93 Dyrektywa #pragma option ........................................................................................93 Dyrektywa #pragma message ....................................................................................93 Dyrektywa #pragma package(smart_init) ..................................................................93 Dyrektywa #pragma resource nazwa_pliku ............................................................93 Dyrektywa #error .......................................................................................................94 Dyrektywy kompilacji warunkowej ...........................................................................94 Kategorie typów danych ...................................................................................................96 Podstawowe proste typy całkowite i rzeczywiste ..............................................................96 Typ int ........................................................................................................................97 Typ double .................................................................................................................97 Modyfikatory typów .........................................................................................................98 Typy danych Windows ...................................................................................................100 Typ Currency ..................................................................................................................101 Typ void .........................................................................................................................101 Typy logiczne .................................................................................................................101 Typy znakowe ................................................................................................................102 Typy łańcuchowe ...........................................................................................................102 Modyfikatory dostępu const i volatile ............................................................................103 Specyfikatory klas pamięci ............................................................................................104 Specyfikator extern ..................................................................................................104 Specyfikator static ....................................................................................................105 Specyfikator register ................................................................................................105 Operatory ........................................................................................................................105 Typ wyliczeniowy ..........................................................................................................109 Słowo kluczowe typedef ................................................................................................109 Typ zbiorowy .................................................................................................................110 Deklarowanie tablic ........................................................................................................111 Instrukcje sterujące przebiegiem programu ...................................................................113 Instrukcja warunkowa if...else .................................................................................113 Instrukcja wyboru switch...case...break ...................................................................115 Instrukcja for ............................................................................................................116 Nieskończona pętla for ............................................................................................118 Instrukcja iteracyjna do...while ................................................................................118 Instrukcja iteracyjna while .......................................................................................119 Instrukcja przerwania wykonywania pętli break .....................................................120 4 (29-05-06/14:06) D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty\_Sp Spis treści 5 Funkcja przerwania programu exit() ........................................................................121 Funkcja przerwania programu abort() .....................................................................122 Instrukcja kontynuacji programu continue ..............................................................122 Funkcje w C++ ...............................................................................................................122 Rekurencja ...............................................................................................................124 Przedefiniowywanie funkcji ....................................................................................125 Niejednoznaczność ..................................................................................................128 Konwencje wywoływania funkcji ............................................................................129 Specyfikatory konsolidacji funkcji ..........................................................................129 Wskazania i adresy .........................................................................................................129 Operatory wskaźnikowe ...........................................................................................133 Wskaźniki i tablice ...................................................................................................133 Wielokrotne operacje pośrednie ..............................................................................135 Operatory new i delete .............................................................................................138 Dereferencja wskaźnika ...........................................................................................138 Wskaźniki ze słowem kluczowym const .................................................................139 Wskaźniki do funkcji ...............................................................................................140 Odwołania ......................................................................................................................145 Parametry odwołaniowe ...........................................................................................147 Zwracanie odwołań przez funkcje ...........................................................................149 Struktury .........................................................................................................................150 Przekazywanie struktur funkcjom ............................................................................152 Struktury zagnieżdżone ............................................................................................153 Wskaźniki do struktur ..............................................................................................155 Samodzielne tworzenie plików nagłówkowych .......................................................156 Unie ................................................................................................................................158 Klasy w C++ ..................................................................................................................159 Przedstawienie w UML ............................................................................................163 Konstruktor i destruktor ...........................................................................................164 Konstruktory kopiowania .........................................................................................166 Inne spojrzenie na klasy. Własności ........................................................................167 Funkcje ogólne .........................................................................................................170 Funkcje z dwoma typami ogólnymi .........................................................................172 Przedefiniowywanie funkcji ogólnych ....................................................................172 Klasy ogólne ............................................................................................................174 Wzorce klas z wieloma ogólnymi typami danych ...................................................176 Wzorzec auto_ptr .....................................................................................................177 Dziedziczenie ...........................................................................................................178 Powiązania ...............................................................................................................183 Funkcje składowe klas ze specyfikatorami const i volatile ............................................186 Funkcje wewnętrzne ................................................................................................188 Realizacja przekazywania egzemplarzy klas funkcjom ...........................................190 Wskaźniki do egzemplarzy klas ...............................................................................191 Operatory (.*) oraz (- *) ..........................................................................................193 Wskaźnik this ...........................................................................................................194 Przeładowywanie operatorów ........................................................................................195 Przeładowywanie jednoargumentowych operatorów ++ oraz – – ...............................196 Przeładowywanie operatorów (!) oraz (!=) ..............................................................199 Przeładowywanie dwuargumentowego operatora arytmetycznego + ......................202 Przeładowywanie operatora .................................................................................204 Przeładowywanie operatora indeksowania tablic [ ] ...............................................205 D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty\_Spis treści.doc (29-05-06/14:06) 5 6 C++Builder Borland Developer Studio 2006. Kompendium programisty Funkcje i klasy zaprzyjaźnione ......................................................................................208 Klasy wejścia-wyjścia języka C++ ................................................................................213 Obsługa plików z wykorzystaniem klasy ios ...........................................................215 Tablicowe operacje wejścia-wyjścia ........................................................................217 Modele programistyczne ................................................................................................220 Programowanie sekwencyjne ...................................................................................221 Programowanie strukturalne ....................................................................................221 Programowanie proceduralne ..................................................................................222 Programowanie obiektowe .......................................................................................224 Programowanie zorientowane obiektowo ................................................................226 Programowanie generyczne .....................................................................................231 Programowanie aspektowe ......................................................................................231 Narzędzia metaprogramowania w C++ ...................................................................232 Programowanie oparte na skompilowanych modułach ...........................................234 Programowanie wielowątkowe ................................................................................235 Programowanie komponentowe ...............................................................................235 Podsumowanie ...............................................................................................................235 Rozdział 4. Wczesne oraz późne wiązanie ..............................................................................................................237 Odwołania i wskaźniki do klas pochodnych ..................................................................237 Funkcje wirtualne w C++ ...............................................................................................240 Wirtualne klasy bazowe .................................................................................................243 Funkcje wirtualne w C++Builderze ...............................................................................247 Klasy abstrakcyjne w stylu biblioteki VCL ...................................................................251 Interfejsy .........................................................................................................................254 Zliczanie odwołań do interfejsu ...............................................................................255 Identyfikator interfejsu .............................................................................................256 Specyfikator __closure ...................................................................................................262 Obszary nazw .................................................................................................................265 Operator __classid ..........................................................................................................265 Funkcja Register() ..........................................................................................................266 Podsumowanie ...............................................................................................................266 Rozdział 5. Rozdział 6. Tablice ...........................................................................................................................................................267 Tablice dynamicznie alokowane w pamięci ...................................................................267 Tablice dynamiczne ........................................................................................................270 Tablice otwarte ...............................................................................................................274 Tablice struktur ..............................................................................................................276 Tablice wskaźników do struktur ..............................................................................279 Odwołania do elementów tablicy wskaźników do struktur .....................................281 Podsumowanie ...............................................................................................................284 Biblioteka STL .......................................................................................................................................... 285 Iteratory ..........................................................................................................................285 Kontenery .......................................................................................................................286 vector ........................................................................................................................286 deque ........................................................................................................................289 list 289 slist ...........................................................................................................................290 set 290 map ...........................................................................................................................291 multiset .....................................................................................................................292 multimap ..................................................................................................................293 6 (29-05-06/14:06) D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty\_Sp Spis treści 7 Rozdział 7. Rozdział 8. hash_set ....................................................................................................................293 hash_map .................................................................................................................294 hash_multiset ...........................................................................................................295 hash_multimap .........................................................................................................296 Obiekty funkcyjne ..........................................................................................................297 Adaptery .........................................................................................................................300 Adaptery iteratorów .................................................................................................300 Adaptery kontenerów ...............................................................................................300 Adaptery obiektów funkcyjnych ..............................................................................302 Algorytmy ......................................................................................................................303 Alokatory ........................................................................................................................305 Valarray ..........................................................................................................................306 Podsumowanie ...............................................................................................................308 Zaawansowane operatory rzutowania typów .............................................................................. 309 Operator static_cast ........................................................................................................309 Operator dynamic_cast ...................................................................................................310 Operator const_cast ........................................................................................................313 Operator reinterpret_cast ................................................................................................316 Podsumowanie ...............................................................................................................317 Informacja czasu wykonania ................................................................................................................319 Klasa TObject .................................................................................................................319 Hierarchia własności komponentów VCL .....................................................................323 Czas życia komponentów ...............................................................................................324 Moduł typeinfo.h ............................................................................................................326 Identyfikacja typów czasu wykonywania ......................................................................328 Tablica metod wirtualnych .............................................................................................330 Klasa TControl ...............................................................................................................331 Modyfikator __rtti ..........................................................................................................333 Podstawowe elementy GUI ............................................................................................334 Przydatne techniki modelowania GUI ...........................................................................335 Agregacje, kompozycje i powiązania klas .....................................................................339 Podsumowanie ...............................................................................................................341 Rozdział 9. Obsługa wyjątków .................................................................................................................................. 343 Standardowa obsługa wyjątków .....................................................................................343 Strukturalna obsługa wyjątków ......................................................................................348 Klasy wyjątków ..............................................................................................................350 Zmienne globalne __throwExceptionName, __throwFileName, __throwLineNumber ...354 Zapisywanie nieobsłużonych wyjątków .........................................................................356 Transformowanie wyjątków Windows ..........................................................................359 Podsumowanie ...............................................................................................................361 Rozdział 10. Obsługa plików ......................................................................................................................................... 363 Klasy TDirectoryListBox, TFileListBox, TDriveComboBox .......................................363 Klasy TActionList, TOpenDialog i TSaveDialog ..........................................................365 Własność Options klas TOpenDialog i TSaveDialog ....................................................372 Klasy TOpenTextFileDialog i TSaveTextFileDialog ....................................................374 Klasy TOpenPictureDialog i TSavePictureDialog ...........................................................374 Klasy TActionManager i TActionMainMenuBar ..........................................................377 D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty\_Spis treści.doc (29-05-06/14:06) 7 8 C++Builder Borland Developer Studio 2006. Kompendium programisty Moduł sysutils ................................................................................................................381 Operacje na plikach ..................................................................................................382 Atrybuty pliku ..........................................................................................................392 Określanie rozmiaru katalogu ..................................................................................397 Usuwanie katalogu ...................................................................................................397 Operacje na dyskach ................................................................................................398 Operacje na nazwach plików ...................................................................................399 Wzajemne przeszukiwanie katalogów i plików .......................................................400 Windows API .................................................................................................................403 Klasa TMemoryStream ..................................................................................................408 Klasa TFileStream ..........................................................................................................411 Tworzenie logów wyjątków podczas kopiowania plików .......................................414 Przesyłanie plików przez sieć ........................................................................................415 Funkcja WinExec() ........................................................................................................419 Funkcja ShellExecuteEx() ..............................................................................................420 Pliki wymiany danych ....................................................................................................420 Kompilowanie plików zasobów .....................................................................................422 Klasa TIniFile .................................................................................................................424 Drukowanie ....................................................................................................................428 Klasa TPrintDialog ..................................................................................................431 Dokumenty XML ...........................................................................................................432 Pliki i katalogi w Linuksie .............................................................................................434 Podsumowanie ...............................................................................................................436 Rozdział 11. Łańcuchy ANSI .......................................................................................................................................437 Makrodefinicja VCL_IOSTREAM ................................................................................445 Znaki wielobajtowe ........................................................................................................448 Podsumowanie ...............................................................................................................449 Rozdział 12. Zmienne o typie modyfikowalnym w czasie wykonywania programu ............................451 Struktura TVarData ........................................................................................................451 Klasa TCustomVariantType ...........................................................................................455 Moduł variants ................................................................................................................457 Tablice wariantowe ........................................................................................................459 Wariantowe tablice otwarte ............................................................................................465 Klient OLE .....................................................................................................................468 Moduł VarCmplx ...........................................................................................................471 Liczby zespolone, płaszczyzna liczbowa, moduł i argument liczby .......................471 Podsumowanie ...............................................................................................................478 Rozdział 13. Funkcje FPU i systemowe ....................................................................................................................479 Funkcje FPU ...................................................................................................................479 Struktura SYSTEM_INFO .............................................................................................485 Klasa THeapStatus .........................................................................................................488 Identyfikator GUID ........................................................................................................491 Klasa TRegistry ..............................................................................................................493 Klasa TRegistryIniFile ...................................................................................................496 Podsumowanie ...............................................................................................................497 Rozdział 14. Elementy wielowątkowości .................................................................................................................499 Wątki i procesy ...............................................................................................................499 Funkcja _beginthread() ..................................................................................................501 Funkcja _beginthreadNT() .............................................................................................504 8 (29-05-06/14:06) D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty\_Sp Spis treści 9 Funkcja _beginthreadex() ...............................................................................................509 Funkcja BeginThread() ..................................................................................................509 Zmienne lokalne wątku ..................................................................................................514 Klasa TThread ................................................................................................................516 Synchronizacja wątków ..................................................................................................522 Sekcje krytyczne ............................................................................................................527 Wzajemne wykluczenia ..................................................................................................529 Uruchamianie zewnętrznych plików wykonywalnych ..................................................531 Wielowątkowe operacje na dyskach, katalogach i plikach ............................................532 Zmienna IsMultiThread ..................................................................................................535 Podsumowanie ...............................................................................................................536 Rozdział 15. Liczby pseudolosowe .............................................................................................................................. 537 Funkcje randomize() i random() ....................................................................................538 Losowanie z powtórzeniami ...........................................................................................543 Losowanie bez powtórzeń ..............................................................................................546 Generatory częściowo uporządkowane ..........................................................................552 Szyfrowanie ....................................................................................................................560 Podsumowanie ...............................................................................................................561 Rozdział 16. Konwersje wielkości liczbowych ....................................................................................................... 563 Podsumowanie ...............................................................................................................587 Rozdział 17. Wprowadzenie do grafiki ..................................................................................................................... 589 Barwne modele ...............................................................................................................590 Płótno .............................................................................................................................593 Mapy bitowe ...................................................................................................................598 JPEG ...............................................................................................................................603 JPEG 2000 ...............................................................................................................606 Obraz video ....................................................................................................................607 Drukowanie grafiki ........................................................................................................611 Komponent TChart .........................................................................................................612 Podsumowanie ...............................................................................................................615 Rozdział 18. Komponentowy model C++Buildera ............................................................................................... 617 Tworzymy nowy komponent .........................................................................................617 Modyfikacja istniejącego komponentu z biblioteki VCL ..............................................626 Komponenty graficzne ...................................................................................................631 Harmonogramowanie zadań ...........................................................................................637 Usuwanie komponentów z pakietu ................................................................................644 Komponenty generyczne ................................................................................................645 Podsumowanie ...............................................................................................................648 Rozdział 19. Biblioteki DLL .........................................................................................................................................649 Łączenie statyczne. Część I ............................................................................................650 Łączenie statyczne. Część II ..........................................................................................652 Ładowanie i zwalnianie bibliotek w czasie działania programu ....................................655 Funkcja DllEntryPoint() .................................................................................................658 Klasy jako elementy bibliotek DLL ...............................................................................661 Bazowe adresy ładowania ..............................................................................................664 Określanie adresów funkcji ............................................................................................664 Komponenty i biblioteki DLL ........................................................................................667 D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty\_Spis treści.doc (29-05-06/14:06) 9 10 C++Builder Borland Developer Studio 2006. Kompendium programisty Pakiety ............................................................................................................................670 Zmienna IsLibrary ..........................................................................................................675 Podsumowanie ...............................................................................................................675 Dodatek A GRAPPLE .................................................................................................................................................677 Zbieranie wymagań ........................................................................................................678 Modelowanie urządzenia .........................................................................................678 Protokół ....................................................................................................................678 Interakcje ..................................................................................................................679 Identyfikacja współpracujących systemów ..............................................................679 Analiza ...........................................................................................................................680 Przypadki użycia ......................................................................................................680 Zmiany stanu systemu ..............................................................................................681 Wstępny model klas programu kontrolującego zewnętrzny system wbudowany ...682 Projektowanie .................................................................................................................682 Statyczny model klas programu kontrolującego zewnętrzny system wbudowany .....683 Diagram artefaktów .................................................................................................684 Diagramy czynności .................................................................................................684 Kodowanie .....................................................................................................................685 Wdrożenie ......................................................................................................................690 Graficzny interfejs użytkownika ....................................................................................691 Kodowanie ...............................................................................................................693 Podsumowanie ...............................................................................................................693 Dodatek B Together ....................................................................................................................................................... 695 Literatura ....................................................................................................................................................707 Skorowidz .....................................................................................................................................................711 10 (29-05-06/14:06) D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty\_S W analizie i projektowaniu zorientowanym obiektowo występują dwa bardzo ważne pojęcia: wczesne oraz późne wiązanie. Z wczesnym wiązaniem (ang. early binding) mamy do czynienia w sytuacjach, gdy funkcje w trakcie kompilacji programu wiąże się z określonymi obiektami. Przykładem wczesnego wiązania będą np. sytuacje, w których w głównej funkcji main() wywo- łujemy funkcje standardowe i przeładowane oraz funkcje przedefiniowywanych standardowych operatorów. Sytuacje, gdy wywoływane funkcje wiązane są z określonymi obiektami w trak- cie działania programu, określamy mianem późnego wiązania (ang. late binding). Przykładem późnego wiązania są klasy pochodne, funkcje wirtualne, klasy polimorficzne i abstrakcyjne. Wielką zaletą technik związanych z późnym wiązaniem jest możliwość stworzenia prawdzi- wego interfejsu użytkownika wraz z odpowiednią biblioteką klas, którą można niemal swobod- nie uzupełniać i modyfikować. Na podstawie wiadomości przedstawionych w poprzednich rozdziałach śmiało możemy wywnio- skować, iż wskaźnik określonego typu nie może wskazywać na dane odmiennych typów. Nie- mniej jednak od tej reguły istnieje pewne bardzo ważne odstępstwo. Rozpatrzmy sytuację, w której zaimplementowaliśmy w programie pewną klasę zwaną klasą bazową oraz klasę z niej dziedzi- czącą — czyli klasę pochodną (potomną). Okazuje się, że wskaźniki do klasy bazowej mogą również w określonych sytuacjach wskazywać na reprezentantów lub elementy klasy pochodnej. Załóżmy, iż w programie zaimplementowaliśmy klasę bazową TStudent z publiczną funkcją składową przechowującą nazwisko pewnego studenta. Następnie stworzymy klasę pochodną TEgzamin z publiczną funkcją składową przechowującą ocenę, jaką otrzymała dana osoba z eg- zaminu z wybranego przedmiotu. W funkcji main() zadeklarujemy zmienną infoStudent jako wskaźnik do klasy TStudent: TStudent *infoStudent; D:Roboczy Jarekmakiety poprawki programisty4.doc (29-05-06/14:07) i druku pdfC++Builder Borland Developer Studio 2006. Kompendium 237 238 C++Builder Borland Developer Studio 2006. Kompendium programisty Zadeklarujmy również po jednym egzemplarzu klas TStudent i TEgzamin: TStudent student; TEgzamin egzamin; Okazuje się, że zmienna deklarowana jako wskaźnik do typu bazowego TStudent może wska- zywać nie tylko na obiekty klasy bazowej, ale również i pochodnej: infoStudent= student; infoStudent= egzamin; Za pomocą tak określonego wskaźnika infoStudent można uzyskać dostęp do wszystkich ele- mentów klasy TEgzamin odziedziczonych po klasie TStudent, tak jak pokazano to na listingu 4.1. Listing 4.1. Kod głównego modułu Unit_R4_01.cpp projektu Projekt_R4_01.bdsproj wykorzystującego wskaźniki i odwołania do typów pochodnych #include iostream #pragma hdrstop using namespace std; class TStudent // klasa bazowa { char nazwisko[40]; public: void __fastcall jakiStudent(char *s) {strcpy(nazwisko, s);} void __fastcall pokazN() {cout nazwisko endl;} }; //--------------------------------------------------------- class TEgzamin: public TStudent // klasa pochodna { char ocena[5]; public: void __fastcall egzaminInformatyka(char *e) {strcpy(ocena, e);} void __fastcall pokazE() {cout ocena endl;} }; //--------------------------------------------------------- int main() { // wskaźnik do klasy TStudent (bazowej) TStudent *infoStudent; // student-egzemplarz klasy TStudent TStudent student; // wskaźnik do klasy TEgzamin (pochodnej) TEgzamin *eInfoStudent; // egzamin-egzemplarz klasy TEgzamin TEgzamin egzamin; // wskaźnik infoStudent wskazuje na egzemplarz // klasy TStudent infoStudent= student; 238(29-05-06/14:07) D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty Rozdział 4. G Wczesne oraz późne wiązanie 239 infoStudent- jakiStudent( Wacek Jankowski ); // wskaźnik infoStudent wskazuje na egzemplarz // klasy Tegzamin, będącej klasą pochodną względem // klasy bazowej TStudent infoStudent= egzamin; infoStudent- jakiStudent( Janek Wackowski ); // sprawdzenie poprawno ci przypisae student.pokazN(); egzamin.pokazN(); cout endl; // funkcje egzaminInformatyka() i pokazE() są // elementami klasy pochodnej. Dostęp do nich uzyskujemy // za pomocą wskaźnika eInfoStudent eInfoStudent = egzamin; eInfoStudent- egzaminInformatyka( Egz. Informatyka 2.5 ); infoStudent- pokazN(); eInfoStudent- pokazE(); cout endl; // uzyskanie dostępu do funkcji składowej klasy pochodnej // za pomocą wskaźnika do klasy bazowej ((TEgzamin *)infoStudent)- pokazE(); cin.get(); return 0; } //--------------------------------------------------------- Śledząc powyższe zapisy, z łatwością przekonamy się, iż wskaźnik do klasy bazowej może równie dobrze wskazywać na te elementy klasy pochodnej, które są zdefiniowane również w kla- sie bazowej, z tego względu, że klasa TEgzamin dziedziczy publiczne elementy klasy TStudent. Jednak, używając w prosty sposób wskaźnika do klasy bazowej, nie można uzyskać dostępu do tych elementów, które występują jedynie w klasie pochodnej. W przypadku, gdy zażądali- byśmy uzyskania dostępu np. do funkcji składowej pokazE() klasy pochodnej, należałoby wy- korzystać zmienną studentInfo będącą jawnym wskaźnikiem do klasy TEgzamin. Jeżeli mimo wszystko ktoś zdecydowałby się, aby za pomocą wskaźnika do klasy bazowej uzyskać dostęp do jakiegoś elementu klasy pochodnej, będzie musiał wykonać w odpowiedni sposób operację rzutowania typów: ((TEgzamin *)infoStudent)- pokazE(); Poprzez wykorzystanie zewnętrznej pary nawiasów informujemy kompilator, iż rzutowanie łączone jest ze wskaźnikiem infoStudent, a nie z wartością funkcji pokazE(). Występowanie we- wnętrznej pary nawiasów określa sytuację, w której wskaźnik infoStudent do klasy bazowej rzutowany jest na typ klasy pochodnej TEgzamin. D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty4.doc (29-05-06/14:07) 239 240 C++Builder Borland Developer Studio 2006. Kompendium programisty Funkcją wirtualną (ang. virtual function) nazywamy taką funkcję, która jest zadeklarowana w klasie bazowej za pomocą słowa kluczowego virtual, a następnie w takiej samej postaci definiowana również w klasach pochodnych. Funkcje takie bardzo często określa się mianem funkcji kategorii virtual. Ponownie definiując funkcję wirtualną w klasie pochodnej, możemy (ale nie musimy) powtórnie umieszczać słowo virtual przed jej nazwą. Funkcje wirtualne mają bardzo ciekawą właściwość. Charakteryzują się mianowicie tym, iż podczas wywoływania do- wolnej z nich za pomocą odwołania lub wskaźnika do klasy bazowej wskazującego na egzem- plarz klasy pochodnej, aktualna wersja wywoływanej funkcji każdorazowo ustalana jest w trakcie wykonywania programu z rozróżnieniem typu wskazywanej klasy. Klasy, w których zdefiniowano jedną lub więcej funkcji wirtualnych, nazywamy klasami polimorficznymi. Jako praktyczny sposób wykorzystania klas polimorficznych rozpatrzmy przykład, gdzie za- deklarowano nieskomplikowaną klasę bazową TBazowa z funkcją pokazB() kategorii virtual, której jedynym zadaniem jest wyświetlenie odpowiedniego tekstu. Ponieważ funkcja jest rze- czywiście funkcją wirtualną, możemy ją z powodzeniem powtórnie zdefiniować (tzn. zdefinio- wać jej kolejną wersję) w klasie pochodnej Tpochodna, dziedziczącej publiczne elementy klasy TBazowa. Sytuację tę ilustruje listing 4.2. Listing 4.2. Kod głównego modułu Unit_R4_02.cpp projektu Projekt_R4_02.bdsproj jako przykład wykorzystania klas polimorficznych #include iostream #pragma hdrstop using namespace std; class TBazowa { public: __fastcall TBazowa() {pokazB();} // konstruktor virtual void __fastcall pokazB() {cout Jestem klasa bazowa endl; } }; //--------------------------------------------------------- class TPochodna : public TBazowa { public: __fastcall TPochodna() {pokazB();} // konstruktor /*virtual*/ void __fastcall pokazB() {cout Jestem klasa pochodna endl;} }; //--------------------------------------------------------- int main() { TPochodna pochodna; // wywołanie funkcji pokazB() cin.get(); return 0; } //--------------------------------------------------------- 240(29-05-06/14:07) D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty Rozdział 4. G Wczesne oraz późne wiązanie 241 Jak łatwo zauważyć, w celu wywołania funkcji pokazB() w głównej funkcji main() zawarto jedynie deklarację egzemplarza klasy pochodnej. Wynika to z faktu, iż zarówno klasa bazowa, jak i pochodna zawierają odpowiednio zaimplementowane konstruktory. Na listingu 4.3 zamieszczono przykład ilustrujący ideę posługiwania się wskaźnikami do klas polimorficznych, co w efekcie pozwala na pominięcie jawnych deklaracji konstruktorów od- powiednich klas. Listing 4.3. Kod głównego modułu Unit_R4_03.cpp projektu Projekt_R4_03.bdsproj wykorzystującego wskaźniki do klas polimorficznych #include iostream #pragma hdrstop using namespace std; class TBazowa { public: virtual void __fastcall pokazB() {cout Jestem klasa bazowa endl; } }; //--------------------------------------------------------- class TPochodna : public TBazowa { public: /*virtual*/ void __fastcall pokazB() {cout Jestem klasa pochodna endl;} }; //--------------------------------------------------------- int main() { TBazowa bazowa; TBazowa *ptrBazowa; TPochodna pochodna; ptrBazowa = bazowa; ptrBazowa- pokazB(); // wywołanie funkcji pokazB() klasy TBazowa ptrBazowa= pochodna; ptrBazowa- pokazB(); // wywołanie funkcji pokazB() klasy TPochodna cin.get(); return 0; } //--------------------------------------------------------- W podanym przykładzie w klasie bazowej definiowana jest funkcja wirtualna pokazB(), po czym jej kolejna wersja zdefiniowana jest względem klasy pochodnej. W głównej funkcji main() zawarto w kolejności deklarację egzemplarza bazowa klasy bazowej, wskaźnika ptrBazowa do klasy bazowej i egzemplarza pochodna klasy pochodnej. Dzięki instrukcjom: ptrBazowa = bazowa; zmienna ptrBazowa uzyskuje adres egzemplarza klasy bazowej, co w konsekwencji pozwala na wykorzystanie jej do wywołania funkcji pokazB() z klasy bazowej: ptrBazowa- pokazB(); D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty4.doc (29-05-06/14:07) 241 242 C++Builder Borland Developer Studio 2006. Kompendium programisty W analogiczny sposób można dokonać wywołania funkcji pokazB() klasy pochodnej, posługując się adresem egzemplarza klasy pochodnej. Ponieważ funkcja pokazB() jest w swoich klasach funkcją wirtualną, zatem w trakcie działania programu decyzja o tym, która wersja tej funkcji jest aktualnie wywoływana, zapada na podstawie określenia typu egzemplarza klasy aktualnie wskazywanego przez wskaźnik ptrBazowa. Podczas pracy z funkcjami wirtualnymi możliwe jest również wykorzystywanie parametru jako odwołania do klasy bazowej. Odpowiednio konstruowane odwołania do klasy bazowej umoż- liwiają wywołanie funkcji wirtualnej z jednoczesnym przekazaniem jej argumentu. Przedsta- wiony na listingu 4.4 program jest modyfikacją algorytmu z poprzedniego ćwiczenia. Zade- klarowano w nim klasę bazową, dwie klasy pochodne oraz funkcję przeładowaną, zawierającą — poprzez parametr formalny x — odwołanie do klasy bazowej: //--------------------------------------------------------- void __fastcall pokazB(TBazowa x) // odwołanie do klasy bazowej { x.pokazB(); return; } //--------------------------------------------------------- Dzięki tak skonstruowanemu odwołaniu aktualna wersji funkcji pokazB(), która powinna być w danym momencie działania programu wywołana, ustalana jest w głównej funkcji main() na podstawie typu, do którego odwołuje się jej parametr aktualny. Listing 4.4. Kod głównego modułu Unit_R4_04.cpp projektu Projekt_R4_04.bdsproj wykorzystującego odwołanie do klasy polimorficznej #include iostream #pragma hdrstop using namespace std; class TBazowa { public: virtual void __fastcall pokazB() {cout Jestem klasa bazowa endl; } }; //--------------------------------------------------------- class TPochodna1 : public TBazowa { public: /*virtual*/ void __fastcall pokazB() {cout Jestem 1 klasa pochodna endl;} }; //--------------------------------------------------------- class TPochodna2 : public TBazowa { public: /*virtual*/ void __fastcall pokazB() {cout Jestem 2 klasa pochodna endl;} }; //--------------------------------------------------------- 242(29-05-06/14:07) D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty Rozdział 4. G Wczesne oraz późne wiązanie 243 void __fastcall pokazB(TBazowa x) // odwołanie do klasy bazowej { x.pokazB(); return; } //--------------------------------------------------------- int main() { TBazowa bazowa; TPochodna1 pochodna1; TPochodna2 pochodna2; pokazB(bazowa); // wywołanie funkcji pokazB() klasy TBazowa pokazB(pochodna1); // wywołanie funkcji pokazB() klasy TPochodna1 pokazB(pochodna2); // wywołanie funkcji pokazB() klasy TPochodna2 cin.get(); return 0; } //--------------------------------------------------------- Wskazówka Bardzo często funkcje zawierające odwołania do klas polimorficznych mają (chociaż niekoniecznie) takie same nazwy, jak funkcje wirtualne względem danej klasy. Chociaż funkcje te mogą mieć takie same nazwy, nie należy utożsamiać ich z funkcjami przeładowanymi. Pomiędzy konstrukcją funkcji przeładowywanych i ponownym definiowaniem funkcji wirtualnych istnieją poważne różnice, np. prototypy funkcji wirtualnych muszą być identyczne, funkcje przeładowane zaś mają różną liczbę lub typ parametrów. Z tego powodu ponowne definiowanie funkcji wirtualnych nazywa się przykrywaniem lub nadpisywaniem funkcji. Tematem poprzedniego podrozdziału były funkcje wirtualne, czyli funkcje deklarowane ze sło- wem kluczowym virtual. Z przedstawionych przykładów łatwo wywnioskujemy, iż wielką ich zaletą jest to, że są one odpowiednio przykrywane w klasach pochodnych. Jednak w języ- ku C++ słowo virtual posiada jeszcze jedno znaczenie, służy mianowicie do deklarowania tzw. wirtualnych klas bazowych. Rozpatrzmy sytuację, w której potrzebujemy zdefiniować w programie pewną klasę bazową TBazowa, dwie klasy pochodne TPochodna1 i TPochodna2 dziedziczące po klasie bazowej i do- datkowo trzecią klasę pochodną TPochodna3, dziedziczącą elementy publiczne klas TPochodna1 i TPochodna2. W każdej z klas zdefiniujmy po jednej funkcji zwracającej pewną wartość całko- witą. Przyjęte założenia ilustruje rysunek 4.1 oraz listing 4.5. D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty4.doc (29-05-06/14:07) 243 244 C++Builder Borland Developer Studio 2006. Kompendium programisty Rysunek 4.1. Idea poziomego dziedziczenia klas. Klasa TPochodna3 dziedziczy poziomo (wielokrotnie) po klasach TPochodna1 i TPochodna2 Listing 4.5. Kod głównego modułu Unit_R4_05.cpp projektu Projekt_R4_05.bdsproj wykorzystującego standardowe klasy bazowe // Program nie zostanie skompilowany ! #include iostream #include vcl #pragma hdrstop using namespace std; class TBazowa { public: int i; int __fastcall pokazB() {cout Jestem klasa bazowa endl; return i; } }; //--------------------------------------------------------- class TPochodna1 : public TBazowa { public: int j; int __fastcall pokazP1() {cout Jestem 1 klasa pochodna endl; return j;} }; //--------------------------------------------------------- 244(29-05-06/14:07) D:Roboczy Jarekmakiety poprawki i druku pdfC++Builder Borland Developer Studio 2006. Kompendium programisty Rozdział 4. G Wczesne oraz późne wiązanie 245 class TPochodna2 : public TBazowa { public: int k; int __fastcall pokazP2() {cout Jestem 2 klasa pochodna endl; return k;} }; //--------------------------------------------------------- // klasa TPochodna3 dziedziczy klasy TPochodna1 i TPochodna2, // i zawiera dwie kopie klasy TBazowa class TPochodna3 : public TPochodna1, public TPochodna2 { public: int l; int __fastcall pokazP3() {cout Jestem 3 klasa pochodna endl; return l;} }; //--------------------------------------------------------- int main() { TPochodna3 klasa; klasa.i = 100; klasa.j = 200; klasa.k = 300; klasa.l = 400; cout klasa.pokazP1() endl; cout klasa.pokazP2() endl; cout klasa.pokazP3() endl; cin.get(); return 0; } //--------------------------------------------------------- Podczas próby uruchomienia powyższego programu spotka nas przykra niespodzianka pole- gająca na tym, że program się po prostu nie skompiluje! Wynika to z faktu, iż jego konstruk- cja jest niejednoznaczna, ponieważ wywołanie: klasa.i = 100; jest dla kompilatora niejednoznaczne: [C++ Error] [nit_E4_05.cpp(44): E2014 (ember is ambiguous: TBazowa::i and TBazowa::i z tego powodu, że każdy egzemplarz klasy TPochodna3 zawiera dwie kopie elementów skła- dowych klasy TBazowa. Ponieważ w tej sytuacji istnieją dwie kopie zmiennej i (deklarowanej w klasie bazowej), kompilator nie ma najmniejszej wiedzy na temat, którą kopię zmiennej ma wykorzystać — tę odziedziczoną przez klasę TPochodna1 czy tę z klasy TPochodna2. Jeżeli dwie lub większa liczba klas dziedziczy z tej samej klasy bazowej, możemy zapobiec sytuacji, w której kopia klasy bazowej jest powielana w klasach potomnych w sposób niekon- trolowany. Istnieje
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C++Builder Borland Developer Studio 2006. Kompendium programisty
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ą: