Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00476 013813 11056518 na godz. na dobę w sumie
Thinking in C++. Edycja polska - książka
Thinking in C++. Edycja polska - książka
Autor: Liczba stron: 648
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-709-3 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).
C++ to jeden z najpopularniejszych języków programowania, w którym napisano szereg profesjonalnych aplikacji, a nawet kilka systemów operacyjnych. Nie bez przyczyny uważany jest on za trudny do opanowania, stanowiąc poważne wyzwanie, zarówno dla programistów, jak i dla autorów podręczników.

Wieloletnie doświadczenie w nauczaniu programowania Bruce'a Eckela gwarantuje, że po przeczytaniu tej książki będziesz posługiwał się C++ tak sprawnie, jak językiem polskim. Bruce Eckel to nie tylko autor bestsellerowych podręczników, takich jak 'Thinking in Java', ale także członek komitetu standaryzującego C++ i szef firmy zajmującej się szkoleniem programistów. Tworzone przez niego kursy programowania uznawane są za jedne z najlepszych na świecie.

Rozpocznij naukę C++ wspólnie z Brucem Eckelem -- jednym z najlepszych dydaktyków programowania na świecie.
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 Thinking in C++. Edycja polska Autor: Bruce Eckel T³umaczenie: Piotr Imiela ISBN: 83-7197-709-3 Tytu³ orygina³u: Thinking in C++ Format: B5, stron: 642 Przyk³ady na ftp: 247 kB C++ to jeden z najpopularniejszych jêzyków programowania, w którym napisano szereg profesjonalnych aplikacji, a nawet kilka systemów operacyjnych. Nie bez przyczyny uwa¿any jest on za trudny do opanowana, stanowi¹c powa¿ne wyzwanie zarówno dla programistów, jak dla autorów podrêczników. Wieloletnie doġwiadczenie w nauczaniu programowania Bruce a Eckela gwarantuje, ¿e po przeczytaniu tej ksi¹¿ki bêdziesz pos³ugiwa³ siê C++ tak sprawnie, jak jêzykiem polskim. Bruce Eckel to nie tylko autor bestsellerowych podrêczników takich jak: Thinking in Java, ale równie¿ cz³onek komitetu standaryzuj¹cego C++ i szef firmy zajmuj¹cy siê szkoleniem programistów. Tworzone przez niego kursy programowania uznawane s¹ za jedne z najlepszych na ġwiecie. • poznasz podstawowe i zaawansowane techniki programowania w C++ • krok po kroku przeġledzisz konstrukcjê jêzyka • nauczysz siê diagnozowaæ i rozwi¹zywaæ problemy w C++ • zwiêz³e, ³atwe do zrozumienia przyk³ady zilustruj¹ przedstawiane zagadnienia • æwiczenia utrwal¹ zdobyte umiejêtnoġci na ka¿dym etapie nauki • kod ĥród³owy zawarty w ksi¹¿ce zgodnie z wieloma kompilorami (w tym z darmowym kompilatorem GNU C++) Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Spis treści Wstęp ...................................................o.......................................... 13 Co nowego w drugim wydaniu?...................................................u.....................................13 Zawartość drugiego tomu książki ...................................................u............................14 Skąd wziąć drugi tom książki? ...................................................u................................14 Wymagania wstępne ...................................................u...................................................u...14 Nauka języka C++...................................................u...................................................u.......15 Cele...............................................u...................................................u..................................16 Zawartość rozdziałów ...................................................u...................................................u.17 Ćwiczenia ...................................................u...................................................u....................21 Rozwiązania ćwiczeń...................................................u...............................................21 Kod źródłowy...................................................u...................................................u..............21 Standardy języka ...................................................u...................................................u.........22 Obsługa języka...................................................u...................................................u......23 Błędy ...................................................u...................................................u.................... .......23 Okładka ...................................................u...................................................u.......................24 Rozdział 1. Wprowadzenie do obiektów ...................................................o........... 25 Postęp abstrakcji...................................................u...................................................u..........26 Obiekt posiada interfejs...................................................u..................................................27 Ukryta implementacja ...................................................u...................................................u.30 Wykorzystywanie istniejącej implementacji...................................................u..................31 Dziedziczenie — wykorzystywanie istniejącego interfejsu..............................................32 Relacje typu „jest” i „jest podobny do” ...................................................u...................35 Zastępowanie obiektówprzy użyciu polimorfizmu ...................................................u........36 Tworzenie i niszczenie obiektów ...................................................u...................................40 Obsługa wyjątków — sposób traktowania błędów ...................................................u........41 Analiza i projektowanie ...................................................u.................................................42 Etap 0. Przygotuj plan...................................................u..............................................44 Etap 1. Co tworzymy?...................................................u..............................................45 Etap 2. Jak to zrobimy?...................................................u............................................49 Etap 3. Budujemy jądro ...................................................u...........................................52 Etap 4. Iteracje przez przypadki użycia ...................................................u...................53 Etap 5. Ewolucja ...................................................u...................................................u...53 Planowanie się opłaca ...................................................u..............................................55 Programowanie ekstremalne ...................................................u..........................................55 Najpierw napisz testy...................................................u...............................................56 Programowanie w parach...................................................u.........................................57 Dlaczego C++ odnosi sukcesy? ...................................................u.....................................58 Lepsze C...................................................u...................................................u................59 Zacząłeś się już uczyć...................................................u..............................................59 6 Thinking in C++. Edycja polska Efektywność...................................................u...................................................u..........60 Systemy są łatwiejsze do opisania i do zrozumienia ..................................................60 Maksymalne wykorzystanie bibliotek ...................................................u.....................60 Wielokrotne wykorzystywanie kodu dzięki szablonom .............................................61 Obsługa błędów ...................................................u...................................................u....61 Programowanie na wielką skalę...................................................u...............................61 Strategie przejścia ...................................................u...................................................u.......62 Wskazówki...................................................u...................................................u............62 Problemy z zarządzaniem ...................................................u........................................64 Podsumowanie ...................................................u...................................................u............66 Rozdział 2. Tworzeniei używanie obiektów...................................................o....... 67 Proces tłumaczenia języka ...................................................u.............................................68 Interpretery...................................................u...................................................u............68 Kompilatory ...................................................u...................................................u..........68 Proces kompilacji...................................................u...................................................u..69 Narzędzia do rozłącznej kompilacji ...................................................u...............................71 Deklaracje i definicje ...................................................u...............................................71 Łączenie ...................................................u...................................................u................76 Używanie bibliotek ...................................................u..................................................76 Twój pierwszy program w C++ ...................................................u.....................................78 Używanie klasy strumieni wejścia-wyjścia ...................................................u.............78 Przestrzenie nazw...................................................u...................................................u..79 Podstawy struktury programu ...................................................u..................................80 „Witaj, świecie!”...................................................u...................................................u...81 Uruchamianie kompilatora...................................................u.......................................82 Więcej o strumieniach wejścia-wyjścia ...................................................u.........................82 Łączenie tablic znakowych ...................................................u......................................83 Odczytywanie wejścia ...................................................u.............................................84 Wywoływanie innych programów...................................................u...........................84 Wprowadzenie do łańcuchów ...................................................u........................................85 Odczytywanie i zapisywanie plików...................................................u..............................86 Wprowadzenie do wektorów...................................................u..........................................88 Podsumowanie ...................................................u...................................................u............92 Ćwiczenia ...................................................u...................................................u....................93 Rozdział 3. Język C w C++...................................................o.............................. 95 Tworzenie funkcji ...................................................u...................................................u.......95 Wartości zwracane przez funkcje ...................................................u............................97 Używanie bibliotek funkcji języka C...................................................u.......................98 Tworzenie własnych bibliotekza pomocą programu zarządzającego bibliotekami....99 Sterowanie wykonywaniem programu...................................................u...........................99 Prawda i fałsz...................................................u...................................................u........99 if-else...................................................u...................................................u...................100 while...................................................u...................................................u....................101 do-while ...................................................u...................................................u..............101 for...................................................u...................................................u........................102 Słowa kluczowe break i continue ...................................................u..........................103 switch ...................................................u...................................................u..................104 Używanie i nadużywanie instrukcji goto...................................................u...............105 Rekurencja ...................................................u...................................................u..........106 Wprowadzenie do operatorów ...................................................u.....................................107 Priorytety...................................................u...................................................u.............107 Automatyczna inkrementacja i dekrementacja ...................................................u......108 Spis treści 7 Wprowadzenie do typów danych ...................................................u.................................108 Podstawowe typy wbudowane...................................................u...............................109 bool, true i false...................................................u...................................................u...110 Specyfikatory ...................................................u...................................................u......111 Wprowadzenie do wskaźników ...................................................u.............................112 Modyfikacja obiektów zewnętrznych ...................................................u....................115 Wprowadzenie do referencji ...................................................u..................................117 Wskaźniki i referencje jako modyfikatory...................................................u.............118 Zasięg ...................................................u...................................................u........................120 Definiowanie zmiennych „w locie” ...................................................u.......................120 Specyfikacja przydziału pamięci...................................................u..................................122 Zmienne globalne...................................................u...................................................u122 Zmienne lokalne...................................................u...................................................u..124 static ...................................................u...................................................u................... .124 extern...................................................u...................................................u...................126 Stałe...................................................u...................................................u.................... .127 volatile...................................................u...................................................u.................129 Operatory i ich używanie ...................................................u.............................................129 Przypisanie...................................................u...................................................u..........130 Operatory matematyczne ...................................................u.......................................130 Operatory relacji ...................................................u...................................................u.131 Operatory logiczne...................................................u.................................................131 Operatory bitowe ...................................................u...................................................u132 Operatory przesunięć ...................................................u.............................................133 Operatory jednoargumentowe...................................................u................................135 Operator trójargumentowy...................................................u.....................................136 Operator przecinkowy...................................................u............................................137 Najczęstsze pułapkizwiązane z używaniem operatorów ..........................................137 Operatory rzutowania...................................................u.............................................138 Jawne rzutowanie w C++...................................................u.......................................139 sizeof — samotny operator ...................................................u....................................143 Słowo kluczowe asm...................................................u..............................................143 Operatory dosłowne ...................................................u...............................................144 Tworzenie typów złożonych ...................................................u........................................144 Nadawanie typom nowych nazw za pomocą typedef ...............................................144 Łączenie zmiennych w struktury ...................................................u...........................145 Zwiększanie przejrzystości programówza pomocą wyliczeń ...................................148 Oszczędzanie pamięci za pomocą unii ...................................................u..................150 Tablice...................................................u...................................................u.................151 Wskazówki dotyczące uruchamiania programów...................................................u........159 Znaczniki uruchomieniowe...................................................u....................................160 Przekształcanie zmiennych i wyrażeń w łańcuchy ...................................................u162 Makroinstrukcja assert( ) języka C ...................................................u........................162 Adresy funkcji ...................................................u...................................................u...........163 Definicja wskaźnika do funkcji ...................................................u.............................163 Skomplikowane deklaracje i definicje ...................................................u...................164 Wykorzystywanie wskaźników do funkcji ...................................................u............165 Tablice wskaźników do funkcji ...................................................u.............................166 Make — zarządzanie rozłączną kompilacją...................................................u.................167 Działanie programu make ...................................................u......................................168 Pliki makefile używane w książce ...................................................u.........................171 Przykładowy plik makefile ...................................................u....................................171 Podsumowanie ...................................................u...................................................u..........173 Ćwiczenia ...................................................u...................................................u..................173 8 Thinking in C++. Edycja polska Rozdział 4. Abstrakcja danych ...................................................o...................... 179 Miniaturowa biblioteka w stylu C...................................................u................................180 Dynamiczny przydział pamięci...................................................u..............................183 Błędne założenia ...................................................u...................................................u.186 Na czym polega problem?...................................................u............................................188 Podstawowy obiekt ...................................................u...................................................u...188 Czym są obiekty? ...................................................u...................................................u......194 Tworzenieabstrakcyjnych typów danych ...................................................u.....................195 Szczegóły dotyczące obiektów...................................................u.....................................196 Zasady używania plików nagłówkowych...................................................u......................197 Znaczenie plików nagłówkowych...................................................u..........................198 Problem wielokrotnych deklaracji ...................................................u.........................199 Dyrektywy preprocesora #define, #ifdef i #endif ...................................................u..200 Standard plików nagłówkowych...................................................u............................201 Przestrzenie nazw w plikach nagłówkowych ...................................................u........202 Wykorzystywanie plików nagłówkowych w projektach ............................................202 Zagnieżdżone struktury ...................................................u................................................202 Zasięg globalny...................................................u...................................................u...206 Podsumowanie ...................................................u...................................................u..........206 Ćwiczenia ...................................................u...................................................u..................207 Rozdział 5. Ukrywanie implementacji ...................................................o............ 211 Określanie ograniczeń ...................................................u..................................................211 Kontrola dostępu w C++ ...................................................u..............................................212 Specyfikator protected ...................................................u...........................................214 Przyjaciele ...................................................u...................................................u.................214 Zagnieżdżeni przyjaciele ...................................................u.......................................216 Czy jest to „czyste”? ...................................................u..............................................218 Struktura pamięci obiektów ...................................................u.........................................219 Klasy...............................................u...................................................u..............................219 Modyfikacja programu Stash, wykorzystująca kontrolę dostępu .............................222 Modyfikacja stosu, wykorzystująca kontrolę dostępu ..............................................223 Klasy-uchwyty ...................................................u...................................................u..........223 Ukrywanie implementacji...................................................u......................................224 Ograniczanie powtórnych kompilacji ...................................................u....................224 Podsumowanie ...................................................u...................................................u..........226 Ćwiczenia ...................................................u...................................................u..................227 Rozdział 6. Inicjalizacjai końcowe porządki ...................................................o... 229 Konstruktor gwarantuje inicjalizację ...................................................u...........................230 Destruktor gwarantuje sprzątanie...................................................u.................................232 Eliminacja bloku definicji ...................................................u............................................233 Pętle for...................................................u...................................................u...............235 Przydzielanie pamięci ...................................................u............................................236 Klasa Stash z konstruktorami i destruktorami...................................................u..............237 Klasa Stack z konstruktorami i destruktorami ...................................................u.............240 Inicjalizacja agregatowa...................................................u...............................................242 Konstruktory domyślne ...................................................u................................................245 Podsumowanie ...................................................u...................................................u..........246 Ćwiczenia ...................................................u...................................................u..................246 Rozdział 7. Przeciążanie nazw funkcji i argumenty domyślne............................. 249 Dalsze uzupełnienia nazw ...................................................u............................................250 Przeciążanie na podstawie zwracanych wartości...................................................u...251 Łączenie bezpieczne dla typów ...................................................u.............................252 Spis treści 9 Przykładowe przeciążenie ...................................................u............................................253 Unie ...................................................u...................................................u...........................255 Argumenty domyślne ...................................................u...................................................u258 Argumenty-wypełniacze ...................................................u........................................259 Przeciążaniekontra argumenty domyślne...................................................u.....................260 Podsumowanie ...................................................u...................................................u..........264 Ćwiczenia ...................................................u...................................................u..................265 Rozdział 8. Stałe ...................................................o.......................................... 267 Podstawianie wartości ...................................................u..................................................267 Stałe w plikach nagłówkowych ...................................................u.............................268 Bezpieczeństwo stałych ...................................................u.........................................269 Agregaty...................................................u...................................................u..............270 Różnice w stosunku do języka C ...................................................u...........................271 Wskaźniki...................................................u...................................................u..................272 Wskaźniki do stałych ...................................................u.............................................272 Stałe wskaźniki ...................................................u...................................................u...273 Przypisanie a kontrola typów...................................................u.................................274 Argumenty funkcji i zwracane wartości...................................................u.......................275 Przekazywanie stałej przez wartość...................................................u.......................275 Zwracanie stałej przez wartość ...................................................u..............................276 Przekazywanie i zwracanie adresów...................................................u......................279 Klasy...............................................u...................................................u..............................282 Stałe w klasach...................................................u...................................................u....282 Stałe o wartościach określonych podczas kompilacji, zawarte w klasach .................285 Stałe obiekty i funkcje składowe ...................................................u...........................287 volatile...................................................u...................................................u.......................292 Podsumowanie ...................................................u...................................................u..........293 Ćwiczenia ...................................................u...................................................u..................294 Rozdział 9. Funkcje inline ...................................................o............................. 297 Pułapki preprocesora ...................................................u...................................................u.298 Makroinstrukcje a dostęp...................................................u.......................................300 Funkcje inline...................................................u...................................................u............301 Funkcje inline wewnątrz klas...................................................u.................................302 Funkcje udostępniające...................................................u..........................................303 Klasy Stash i Stack z funkcjami inline...................................................u.........................308 Funkcje inline a kompilator...................................................u..........................................311 Ograniczenia ...................................................u...................................................u.......312 Odwołania do przodu...................................................u.............................................313 Działania ukryte w konstruktorach i destruktorach ..................................................313 Walka z bałaganem ...................................................u...................................................u...314 Dodatkowe cechy preprocesora ...................................................u...................................315 Sklejanie symboli...................................................u...................................................u316 Udoskonalona kontrola błędów...................................................u....................................316 Podsumowanie ...................................................u...................................................u..........319 Ćwiczenia ...................................................u...................................................u..................320 Rozdział 10. Zarządzanie nazwami ...................................................o.................. 323 Statyczne elementy języka C...................................................u........................................323 Zmienne statyczne znajdujące się wewnątrz funkcji ................................................324 Sterowanie łączeniem ...................................................u............................................328 Inne specyfikatory klas pamięci...................................................u.............................330 Przestrzenie nazw...................................................u...................................................u......330 Tworzenie przestrzeni nazw ...................................................u..................................330 Używanie przestrzeni nazw ...................................................u...................................332 Wykorzystywanie przestrzeni nazw ...................................................u......................336 10 Thinking in C++. Edycja polska Statyczne składowe w C++ ...................................................u..........................................337 Definiowanie pamięcidla statycznych danych składowych......................................337 Klasy zagnieżdżone i klasy lokalne ...................................................u.......................341 Statyczne funkcje składowe...................................................u...................................342 Zależności przy inicjalizacjiobiektów statycznych ...................................................u......344 Jak można temu zaradzić? ...................................................u.....................................346 Specyfikacja zmiany sposobu łączenia ...................................................u........................352 Podsumowanie ...................................................u...................................................u..........353 Ćwiczenia ...................................................u...................................................u..................353 Rozdział 11. Referencjei konstruktor kopiujący .................................................. 359 Wskaźniki w C++...................................................u...................................................u......359 Referencje w C++ ...................................................u...................................................u.....360 Wykorzystanie referencji w funkcjach ...................................................u..................361 Wskazówki dotyczące przekazywania argumentów.................................................363 Konstruktor kopiujący...................................................u..................................................363 Przekazywanie i zwracanie przez wartość...................................................u.............364 Konstrukcja za pomocą konstruktora kopiującego ...................................................u369 Domyślny konstruktor kopiujący...................................................u...........................374 Możliwości zastąpienia konstruktora kopiującego ...................................................u376 Wskaźniki do składowych...................................................u............................................378 Funkcje...................................................u...................................................u................380 Podsumowanie ...................................................u...................................................u..........382 Ćwiczenia ...................................................u...................................................u..................383 Rozdział 12. Przeciążanie operatorów ...................................................o............. 387 Ostrzeżenie i wyjaśnienie...................................................u.............................................387 Składnia...................................................u...................................................u................. ....388 Operatory, które można przeciążać...................................................u..............................389 Operatory jednoargumentowe...................................................u................................390 Operatory dwuargumentowe...................................................u..................................393 Argumenty i zwracane wartości...................................................u.............................402 Nietypowe operatory...................................................u..............................................405 Operatory, których nie można przeciążać...................................................u..............412 Operatory niebędące składowymi ...................................................u................................413 Podstawowe wskazówki ...................................................u........................................414 Przeciążanie operacji przypisania ...................................................u................................415 Zachowanie się operatora = ...................................................u...................................416 Automatyczna konwersja typów ...................................................u..................................425 Konwersja za pomocą konstruktora...................................................u.......................425 Operator konwersji...................................................u.................................................427 Przykład konwersji typów...................................................u......................................429 Pułapki automatycznej konwersji typów ...................................................u...............430 Podsumowanie ...................................................u...................................................u..........432 Ćwiczenia ...................................................u...................................................u..................432 Rozdział 13. Dynamiczne tworzenie obiektów ...................................................o.. 437 Tworzenie obiektów...................................................u...................................................u..438 Obsługa sterty w języku C ...................................................u.....................................439 Operator new...................................................u...................................................u.......440 Operator delete...................................................u...................................................u....441 Prosty przykład ...................................................u...................................................u...442 Narzut menedżera pamięci...................................................u.....................................442 Spis treści 11 Zmiany w prezentowanych wcześniej przykładach ...................................................u.....443 Usuwanie wskaźnika void* jest prawdopodobnie błędem .......................................443 Odpowiedzialność za sprzątanie wskaźników ...................................................u.......445 Klasa Stash przechowująca wskaźniki...................................................u...................445 Operatory new i delete dla tablic...................................................u..................................450 Upodabnianie wskaźnika do tablicy ...................................................u......................451 Brak pamięci ...................................................u...................................................u.............451 Przeciążanie operatorów new i delete ...................................................u..........................452 Przeciążanie globalnych operatorów new i delete ...................................................u.453 Przeciążanie operatorów new i delete w obrębie klasy .................................................455 Przeciążanie operatorów new i deletew stosunku do tablic......................................458 Wywołania konstruktora...................................................u........................................460 Operatory umieszczania new i delete ...................................................u....................461 Podsumowanie ...................................................u...................................................u..........463 Ćwiczenia ...................................................u...................................................u..................463 Rozdział 14. Dziedziczeniei kompozycja...................................................o........... 467 Składnia kompozycji ...................................................u...................................................u.468 Składnia dziedziczenia ...................................................u.................................................469 Lista inicjatorów konstruktora ...................................................u.....................................471 Inicjalizacja obiektów składowych ...................................................u........................471 Typy wbudowane znajdujące się na liście inicjatorów.............................................472 Łączenie kompozycji i dziedziczenia...................................................u...........................473 Kolejność wywoływaniakonstruktorów i destruktorów ...........................................474 Ukrywanie nazw...................................................u...................................................u........476 Funkcje, które nie są automatycznie dziedziczone ...................................................u......480 Dziedziczenie a statyczne funkcje składowe ...................................................u.........483 Wybór między kompozycją a dziedziczeniem...................................................u.............484 Tworzenie podtypów ...................................................u.............................................485 Dziedziczenie prywatne ...................................................u.........................................487 Specyfikator protected...................................................u..................................................488 Dziedziczenie chronione...................................................u........................................489 Przeciążanie operatorów a dziedziczenie...................................................u.....................490 Wielokrotne dziedziczenie ...................................................u...........................................491 Programowanie przyrostowe...................................................u........................................492 Rzutowanie w górę...................................................u...................................................u....492 Dlaczego „rzutowanie w górę”? ...................................................u............................494 Rzutowanie w górę a konstruktor kopiujący ...................................................u.........494 Kompozycja czy dziedziczenie (po raz drugi)...................................................u.......497 Rzutowanie w górę wskaźników i referencji ...................................................u.........498 Kryzys ...................................................u...................................................u.................498 Podsumowanie ...................................................u...................................................u..........498 Ćwiczenia ...................................................u...................................................u..................499 Rozdział 15. Polimorfizmi funkcje wirtualne...................................................o..... 503 Ewolucja programistów języka C++...................................................u............................504 Rzutowanie w górę...................................................u...................................................u....504 Problem ...................................................u...................................................u.................. ...506 Wiązanie wywołania funkcji...................................................u..................................506 Funkcje wirtualne...................................................u...................................................u......506 Rozszerzalność...................................................u...................................................u....508 W jaki sposób język C++ realizuje późne wiązanie?...................................................u...510 Przechowywanie informacji o typie...................................................u.......................511 Obraz funkcji wirtualnych ...................................................u.....................................512 12 Thinking in C++. Edycja polska Rzut oka pod maskę ...................................................u...............................................514 Instalacja wskaźnika wirtualnego ...................................................u..........................515 Obiekty są inne ...................................................u...................................................u...516 Dlaczego funkcje wirtualne?...................................................u........................................517 Abstrakcyjne klasy podstawowe i funkcje czysto wirtualne...........................................518 Czysto wirtualne definicje ...................................................u.....................................522 Dziedziczenie i tablica VTABLE...................................................u.................................523 Okrajanie obiektów...................................................u................................................525 Przeciążanie i zasłanianie...................................................u.............................................527 Zmiana typu zwracanej wartości ...................................................u...........................529 Funkcje wirtualne a konstruktory...................................................u.................................530 Kolejność wywoływania konstruktorów...................................................u................531 Wywoływanie funkcji wirtualnychwewnątrz konstruktorów...................................532 Destruktory i wirtualne destruktory ...................................................u.............................533 Czysto wirtualne destruktory ...................................................u.................................535 Wirtualne wywołania w destruktorach ...................................................u..................537 Tworzenie hierarchii bazującej na obiekcie...................................................u...........538 Przeciążanie operatorów ...................................................u..............................................541 Rzutowanie w dół...................................................u...................................................u......543 Podsumowanie ...................................................u...................................................u..........546 Ćwiczenia ...................................................u...................................................u..................546 Rozdział 16. Wprowadzenie do szablonów ...................................................o....... 551 Kontenery ...................................................u...................................................u..................551 Potrzeba istnienia kontenerów ...................................................u...............................553 Podstawy szablonów ...................................................u...................................................u.554 Rozwiązanie z wykorzystaniem szablonów...................................................u...........556 Składnia szablonów...................................................u...................................................u...558 Definicje funkcji niebędących funkcjami inline ...................................................u....559 Klasa IntStack jako szablon ...................................................u...................................560 Stałe w szablonach...................................................u.................................................562 Klasy Stack i Stash jako szablony...................................................u................................563 Kontener wskaźników Stash,wykorzystujący szablony ...........................................565 Przydzielanie i odbieranieprawa własności...................................................u..................570 Przechowywanie obiektówjako wartości ...................................................u.....................573 Wprowadzenie do iteratorów ...................................................u.......................................575 Klasa Stack z iteratorami ...................................................u.......................................582 Klasa PStash z iteratorami ...................................................u.....................................585 Dlaczego iteratory? ...................................................u...................................................u...590 Szablony funkcji ...................................................u...................................................u.593 Podsumowanie ...................................................u...................................................u..........594 Ćwiczenia ...................................................u...................................................u..................594 Dodatek A Styl kodowania ...................................................o........................... 599 Dodatek B Wskazówki dla programistów ...................................................o...... 609 Dodatek C Zalecana literatura ...................................................o..................... 621 Język C ...................................................u...................................................u......................621 Ogólnie o języku C++ ...................................................u..................................................621 Książki, które napisałem...................................................u........................................622 Głębia i mroczne zaułki...................................................u................................................623 Analiza i projektowanie ...................................................u...............................................623 Skorowidz...................................................o................................... 627 Rozdział 5. Ukrywanie implementacji Typowa biblioteka składa się w języku C ze struktury i kilku dołączonych funkcji, wykonujących na niej operacje. Zapoznaliśmy się ze sposobem, w jaki język C++ grupuje funkcje, związane ze sobą pojęciowo, i łączy je literalnie. Dokonuje tego umieszczając deklaracje funkcji w obrębie zasięgu struktury, zmieniając sposób, w jaki funkcje te są wywoływane w stosunku do tej struktury, eliminując przekazy- wanie adresu struktury jako pierwszego argumentu i dodając do programu nazwę no- wego typu (dzięki czemu nie trzeba używać słowa kluczowego typedef w stosunku do identyfikatora struktury). Wszystko to zapewnia większą wygodę — pozwala lepiej zorganizować kod i ułatwia zarówno jego napisanie, jak i przeczytanie. Warto jednak poruszyć jeszcze inne ważne zagadnienia, związane z łatwiejszym tworzeniem bibliotek w języku C++ — w szcze- gólności są to kwestie, dotyczące bezpieczeństwa i kontroli. W niniejszym rozdziale za- poznamy się bliżej z kwestiami ograniczeń dotyczących lstruktur. Określanie ograniczeń W każdej relacji istotne jest określenie granic, respektowanych przez wszystkie zaanga- żowane w nią strony. Tworząc bibliotekę, ustanawiasz relację z klientem-programistą, używającym twojej biblioteki do zbudowania aplikacji lub utworzenia innej biblioteki. W strukturach dostępnych w języku C, podobnie jak w większości elementów tego języka, nie obowiązują żadne reguły. Klienci-programiści mogą postąpić dowolnie ze strukturą i nie ma żadnego sposobu, by wymusić na nich jakiekolwiek szczególne za- chowania. Na przykład mimo ważności funkcji o nazwach initialize( ) i cleanup( ) (wskazanej w poprzednim rozdziale), klient-programista może w ogóle ich nie wy- wołać (lepsze rozwiązanie tej kwestii zaprezentujemy w następnym rozdziale). W ję- zyku C nie ma żadnego sposobu zapobieżenia temu, by klienci-programiści operowali bezpośrednio na niektórych składowych struktur. Wszylstko ma charakter jawny. 212 Thinking in C++. Edycja polska Istnieją dwa powody wprowadzenia kontroli dostępu do składowych struktur. Przede wszystkim programistom należy uniemożliwić stosowanie narzędzi niezbędnych do wykonywania wewnętrznych operacji związanych z typem danych, lecz niebędących częścią interfejsu potrzebnego klientom-programistom do rozwiązania ich własnych problemów. Jest to w rzeczywistości pomoc udzielana klientom-programistom, po- nieważ dzięki temu mogą łatwo odróżnić kwestie istotne old pozostałych. Drugim powodem wprowadzenia kontroli dostępu jest umożliwienie projektantowi biblioteki zmiany wewnętrznych mechanizmów struktury z pominięciem wpływu na klienta-programistę. W przykładzie ze stosem, przedstawionym w poprzednim roz- dziale, z uwagi na szybkość można by przydzielać pamięć dużymi porcjami zamiast tworzyć kolejny jej obszar, ilekroć dodawany jest nowy element. Jeżeli interfejs oraz implementacja są wyraźnie od siebie oddzielone i chronione, można tego dokonać, wymagając od klienta-programisty jedynie przeprowadzenia ponownego łączenia modułów wynikowych. Kontrola dostępu w C++ Język C++ wprowadza trzy nowe słowa kluczowe, pozwalające na określenie granic w obrębie struktur: public (publiczny), private (prywatny) i protected (chroniony). Sposób ich użycia oraz znaczenie wydają się dość oczywiste. Są one specyfikatorami dostępu (ang. access specifiers), używanymi wyłącznie w deklaracjach struktur, zmieniającymi ograniczenia dla wszystkich następujących po nich definicji. Specyfi- kator dostępu zawsze musi kończyć się średnikiem. Specyfikator public oznacza, że wszystkie następujące po nim deklaracje składowych są dostępne dla wszystkich. Składowe publiczne są takie same, jak zwykłe składowe struktur. Na przykład poniższe deklaracje struktur slą identyczne:  2WDNKEERR 5RGE[HKMCVQTRWDNKERT\[RQOKPC\Y[MđG UVTWMVWT[Lú\[MC UVTWEV#] KPVK EJCTL HNQCVH XQKFHWPE  _ XQKF#HWPE ]_ UVTWEV$] RWDNKE KPVK EJCTL HNQCVH XQKFHWPE  _ Rozdział 5. ♦ Ukrywanie implementacji 213 XQKF$HWPE ]_ KPVOCKP ] #C$D CKDK CLDL E  CHDH CHWPE  DHWPE  _` Z kolei słowo kluczowe private oznacza, że do składowych struktury nie ma dostępu nikt, oprócz ciebie, twórcy typu, i to jedynie w obrębie funkcji składowych tego typu. Specyfikator private stanowi barierę pomiędzy tobą i klientem-programistą — każdy, kto spróbuje odwołać się do prywatnej składowej klasy, otrzyma komunikat o błędzie już na etapie kompilacji. W powyższej strukturze B mógłbyś chcieć na przykład ukryć część jej reprezentacji (tj. danych składowych), dzięki czemu byłyby one do- stępne wyłącznie dla ciebie:  2TKXCVGERR 1MTGħNCPKGITCPKE[ UVTWEV$] RTKXCVG EJCTL HNQCVH RWDNKE KPVK XQKFHWPE  _ XQKF$HWPE ] K L   H _ KPVOCKP ] $D DK1-UMđCFQYCRWDNKE\PC DL  0KGFQ\YQNQPGUMđCFQYCRT[YCVPC DH0KGFQ\YQNQPGUMđCFQYCRT[YCVPC _` Mimo że funkcja func( ) ma dostęp do każdej składowej struktury B (ponieważ jest ona również składową struktury B, więc automatycznie uzyskuje do tego prawo), to zwykła funkcja globalna, taka jak main( ), nie posiada takich uprawnień. Oczywiście, do tych składowych nie mają dostępu również funkcje składowe innych struktur. Wyłącznie funkcje, które zostały wyraźnie wymienione w deklaracji struktury („kon- trakt”), mają dostęp do prywatnych składowych struktury. Nie istnieje określony porządek, w jakim powinny występować specyfikatory dostępu; mogą one również występować więcej niż jednokrotnie. Dotyczą one wszystkich zade- klarowanych po nich składowych, aż do napotkania nalstępnego specyfikatora dostępu. 214 Thinking in C++. Edycja polska Specyfikator protected Ostatnim specyfikatorem dostępu jest protected. Jego znaczenie jest zbliżone do spe- cyfikatora private, z jednym wyjątkiem, który nie może zostać jeszcze teraz wyja- śniony — struktury „dziedziczące” (które nie posiadają dostępu do składowych pry- watnych) mają zagwarantowany dostęp do składowych oznaczonych specyfikatorem protected. Zostanie to wyjaśnione w rozdziale 14., przy okazji wprowadzenia pojęcia dziedziczenia. Tymczasowo można przyjąć, że specyfikator protected działa podob- nie do specyfikatora private. Przyjaciele Co zrobić w sytuacji, gdy chcemy jawnie udzielić pozwolenia na dostęp funkcji, niebę- dącej składową bieżącej struktury? Uzyskuje się to, deklarując funkcję za pomocą słowa kluczowego friend (przyjaciel) wewnątrz deklaracji struktury. Ważne jest, by deklaracja friend występowała w obrębie deklaracji struktury, ponieważ programista (i kompilator), czytając deklarację struktury, musi poznać wszystkie zasady dotyczące wielkości i za- chowania tego typu danych. A niezwykle ważną zasadę, obowiązującą w każdej relacji, stanowi odpowiedź na pytanie: „Kto ma dostęp do mojej plrywatnej implementacji?”. To sama struktura określa, który kod ma dostęp do jej składowych. Nie ma żadnego ma- gicznego sposobu „włamania się” z zewnątrz, jeżeli nie jest się „przyjacielem” — nie można zadeklarować nowej klasy, twierdząc: „Cześć, jestem przyjacielem Boba!” i spo- dziewając się, że zapewni to dostęp do prywatnych il chronionych składowych klasy Bob. Wolno zadeklarować jako „przyjaciela” funkcję globalną; może nim być również składowa innej struktury albo nawet cała struktura zadeklarowana z użyciem słowa kluczowego friend. Poniżej zamieszczono przykład:  (TKGPFERR 5đQYQMNWE\QYGHTKGPFFCLGURGELCNPG RTCYCFQUVúRW  GMNCTCELC PKGMQORNGVPCURGE[HKMCELCV[RW  UVTWEV: UVTWEV;] XQKFH :  _ UVTWEV:] GHKPKELC RTKXCVG KPVK RWDNKE XQKFKPKVKCNK\G  HTKGPFXQKFI : KPV 2T\[LCEKGNINQDCNP[ HTKGPFXQKF;H : 2T\[LCEKGNDúFæE[UMđCFQYæUVTWMNVWT[ HTKGPFUVTWEV  CđCUVTWMVWTCLCMQRT\[LCEKGN HTKGPFXQKFJ  _ Rozdział 5. ♦ Ukrywanie implementacji 215 XQKF:KPKVKCNK\G ] K _ XQKFI : ZKPVK ] Z KK _ XQKF;H : Z ] Z K _ UVTWEV ] RTKXCVG KPVL RWDNKE XQKFKPKVKCNK\G  XQKFI : Z  _ XQKF KPKVKCNK\G ] L _ XQKF I : Z ] Z K L _ XQKFJ ] :Z ZK$G\RQħTGFPKCQRGTCELCPCUMđCFQYGL _ KPVOCKP ] :Z  \ \I Z  _` Struktura Y posiada funkcję składową f( ), modyfikującą obiekt typu X. Jest to nieco zagadkowe, ponieważ kompilator języka C++ wymaga zadeklarowania każdej rzeczy przed odwołaniem się do niej. Należy więc zadeklarować strukturę Y, zanim jeszcze jej składowa Y::f(X*) będzie mogła zostać zadeklarowana jako przyjaciel struktury X. Jednakże, aby funkcja Y::f(X*) mogła zostać zadeklarowana, najpierw należy za- deklarować strukturę X! Oto rozwiązanie. Zwróć uwagę na to, że funkcja Y::f(X*) pobiera adres obiektu X. Jest to istotne, ponieważ kompilator zawsze wie, w jaki sposób przekazać adres będą- cy stałej wielkości, niezależnie od przekazywanego za jego pośrednictwem obiektu i nawet jeżeli nie posiada pełnej informacji dotyczącej jego wielkości. Jednakże w przypadku próby przekazania całego obiektu kompilator musi widzieć całą defini- cję struktury X, aby poznać jej wielkość i wiedzieć, w jaki sposób jlą przekazać, zanim pozwoli na deklarację funkcji w rodzaju Y::g(X). 216 Thinking in C++. Edycja polska Przekazując adres struktury X, kompilator pozwala na utworzenie niepełnej specyfi- kacji typu X, umieszczonej przed deklaracją Y::f(X*). Uzyskuje się ją za pomocą de- klaracji: UVTWEV: Deklaracja ta informuje kompilator, że istnieje struktura o podanej nazwie, więc moż- na odwołać się do niej, dopóki nie jest na jej temat potrzebna żadna dodatkowa wie- dza, poza nazwą. Potem funkcja Y::f(X*) w strukturze X może być już bez problemu zadeklarowana jako „przyjaciel”. W razie próby zadeklarowania jej, zanim kompilator napotka pełną specyfikację klasy Y, nastąpiłoby zgłoszenie błędu. Jest to cecha zapewniająca bez- pieczeństwo i spójność, a także zapobiegająca błędom. Zwróć uwagę na dwie pozostałe funkcje zadeklarowane z użyciem słowa kluczowego friend. Pierwsza z nich deklaruje jako przyjaciela zwykłą funkcję globalną g( ). Funkcja ta nie została jednak wcześniej zadeklarowana w zasięgu globalnym! Oka- zuje się, że taki sposób użycia deklaracji friend może zostać wykorzystany do rów- noczesnego zadeklarowania funkcji i nadania jej statusu przyjaciela. Dotyczy to rów- nież całych struktur. Deklaracja: HTKGPFUVTWEV  jest niepełną specyfikacją typu struktury Z, nadającą równocześnie całej tej strukturze status przyjaciela. Zagnieżdżeni przyjaciele Utworzenie struktury zagnieżdżonej nie zapewnia jej automatycznie prawa dostępu do składowych prywatnych. Aby to osiągnąć, należy postąpić w szczególny sposób: najpierw zadeklarować (nie definiując) strukturę zagnieżdżoną, następnie zadeklaro- wać ją, używając słowa kluczowego friend, a na koniec — zdefiniować strukturę. Definicja struktury musi być oddzielona od deklaracji friend, bo w przeciwnym przypadku kompilator nie uznałby jej za składową struktury. Poniżej zamieszczono przykład takiego zagnieżdżenia struktury:  0GUV(TKGPFERR  CIPKGľFľGPKRT\[LCEKGNG KPENWFGKQUVTGCO KPENWFGEUVTKPI OGOUGV WUKPIPCOGURCEGUVF EQPUVKPVU\ UVTWEV*QNFGT] RTKXCVG KPVC=U\? RWDNKE XQKFKPKVKCNK\G  UVTWEV2QKPVGT HTKGPF2QKPVGT UVTWEV2QKPVGT] Rozdział 5. ♦ Ukrywanie implementacji 217 RTKXCVG *QNFGT J KPV R RWDNKE XQKFKPKVKCNK\G *QNFGT J  2QTWU\CPKGUKúYQDTúDKGVCDNKE[ XQKFPGZV  XQKFRTGXKQWU  XQKFVQR  XQKFGPF   QUVúRFQYCTVQħEK KPVTGCF  XQKFUGV KPVK  _ _ XQKF*QNFGTKPKVKCNK\G ] OGOUGV CU\ UK\GQH KPV  _ XQKF*QNFGT2QKPVGTKPKVKCNK\G *QNFGT TX ] JTX RTX C _ XQKF*QNFGT2QKPVGTPGZV ] KH R J C=U\? R  _ XQKF*QNFGT2QKPVGTRTGXKQWU ] KH R  J C=? R _ XQKF*QNFGT2QKPVGTVQR ] R J C=?  _ XQKF*QNFGT2QKPVGTGPF ] R J C=U\?  _ KPV*QNFGT2QKPVGTTGCF ] TGVWTP R _ XQKF*QNFGT2QKPVGTUGV KPVK ]  RK _ KPVOCKP ] *QNFGTJ *QNFGT2QKPVGTJRJR KPVK JKPKVKCNK\G  JRKPKVKCNK\G J  JRKPKVKCNK\G J  218 Thinking in C++. Edycja polska HQT KKU\K ] JRUGV K  JRPGZV  _ JRVQR  JRGPF  HQT KKU\K ] EQWVJRJRTGCF JRJRTGCF GPFN JRPGZV  JRRTGXKQWU  _ _` Po zadeklarowaniu struktury Pointer deklaracja: HTKGPF2QKPVGT zapewnia jej dostęp do prywatnych składowych struktury Holder. Struktura Holder zawiera tablicę liczb całkowitych, do których dostęp jest możliwy właśnie dzięki struk- turze Pointer. Ponieważ struktura Pointer jest ściśle związana ze strukturą Holder, roz- sądne jest uczynienie z niej składowej struktury Holder. Ponieważ jednak Pointer sta- nowi oddzielną strukturę w stosunku do struktury Holder, można utworzyć w funkcji main( ) większą liczbę jej egzemplarzy, używając ich następnie do wyboru różnych fragmentów tablicy. Pointer jest strukturą z niezwykłym wskaźnikiem języka C, gwa- rantuje więc zawsze poprawne wskazania w obrębie stlruktury Holder. Funkcja memset( ), wchodząca w skład standardowej biblioteki języka C (zadeklaro-
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Thinking in C++. Edycja polska
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ą: