Bruce Eckel - Thinking in C++

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.

* Poznasz podstawowe i zaawansowane techniki programowania w C++
* Krok po kroku prześledzisz konstrukcje 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 zgodny jest z wieloma kompilatorami (w tym z darmowym kompilatorem GNU C++)

SPIS TREŚCI

Wstęp (13)

* Co nowego w drugim wydaniu? (13)
o Zawartość drugiego tomu książki (14)
o Skąd wziąć drugi tom książki? (14)
* Wymagania wstępne (14)
* Nauka języka C++ (15)
* Cele (16)
* Zawartość rozdziałów (17)
* Ćwiczenia (21)
o Rozwiązania ćwiczeń (21)
* Kod źródłowy (21)
* Standardy języka (22)
o Obsługa języka (23)
* Błędy (23)
* Okładka (24)

Rozdział 1. Wprowadzenie do obiektów (25)

* Postęp abstrakcji (26)
* Obiekt posiada interfejs (27)
* Ukryta implementacja (30)
* Wykorzystywanie istniejącej implementacji (31)
* Dziedziczenie - wykorzystywanie istniejącego interfejsu (32)
o Relacje typu "jest" i "jest podobny do" (35)
* Zastępowanie obiektów przy użyciu polimorfizmu (36)
* Tworzenie i niszczenie obiektów (40)
* Obsługa wyjątków - sposób traktowania błędów (41)
* Analiza i projektowanie (42)
o Etap 0. Przygotuj plan (44)
o Etap 1. Co tworzymy? (45)
o Etap 2. Jak to zrobimy? (49)
o Etap 3. Budujemy jądro (52)
o Etap 4. Iteracje przez przypadki użycia (53)
o Etap 5. Ewolucja (53)
o Planowanie się opłaca (55)
* Programowanie ekstremalne (55)
o Najpierw napisz testy (56)
o Programowanie w parach (57)
* Dlaczego C++ odnosi sukcesy? (58)
o Lepsze C (59)
o Zacząłeś się już uczyć (59)
o Efektywność (60)
o Systemy są łatwiejsze do opisania i do zrozumienia (60)
o Maksymalne wykorzystanie bibliotek (60)
o Wielokrotne wykorzystywanie kodu dzięki szablonom (61)
o Obsługa błędów (61)
o Programowanie na wielką skalę (61)
* Strategie przejścia (62)
o Wskazówki (62)
o Problemy z zarządzaniem (64)
* Podsumowanie (66)

Rozdział 2. Tworzenie i używanie obiektów (67)

* Proces tłumaczenia języka (68)
o Interpretery (68)
o Kompilatory (68)
o Proces kompilacji (69)
* Narzędzia do rozłącznej kompilacji (71)
o Deklaracje i definicje (71)
o Łączenie (76)
o Używanie bibliotek (76)
* Twój pierwszy program w C++ (78)
o Używanie klasy strumieni wejścia-wyjścia (78)
o Przestrzenie nazw (79)
o Podstawy struktury programu (80)
o "Witaj, świecie!" (81)
o Uruchamianie kompilatora (82)
* Więcej o strumieniach wejścia-wyjścia (82)
o Łączenie tablic znakowych (83)
o Odczytywanie wejścia (84)
o Wywoływanie innych programów (84)
* Wprowadzenie do łańcuchów (85)
* Odczytywanie i zapisywanie plików (86)
* Wprowadzenie do wektorów (88)
* Podsumowanie (92)
* Ćwiczenia (93)

Rozdział 3. Język C w C++ (95)

* Tworzenie funkcji (95)
o Wartości zwracane przez funkcje (97)
o Używanie bibliotek funkcji języka C (98)
o Tworzenie własnych bibliotek za pomocą programu zarządzającego bibliotekami (99)
* Sterowanie wykonywaniem programu (99)
o Prawda i fałsz (99)
o if-else (100)
o while (101)
o do-while (101)
o for (102)
o Słowa kluczowe break i continue (103)
o switch (104)
o Używanie i nadużywanie instrukcji goto (105)
o Rekurencja (106)
* Wprowadzenie do operatorów (107)
o Priorytety (107)
o Automatyczna inkrementacja i dekrementacja (108)
* Wprowadzenie do typów danych (108)
o Podstawowe typy wbudowane (109)
o bool, true i false (110)
o Specyfikatory (111)
o Wprowadzenie do wskaźników (112)
o Modyfikacja obiektów zewnętrznych (115)
o Wprowadzenie do referencji (117)
o Wskaźniki i referencje jako modyfikatory (118)
* Zasięg (120)
o Definiowanie zmiennych "w locie" (120)
* Specyfikacja przydziału pamięci (122)
o Zmienne globalne (122)
o Zmienne lokalne (124)
o static (124)
o extern (126)
o Stałe (127)
o volatile (129)
* Operatory i ich używanie (129)
o Przypisanie (130)
o Operatory matematyczne (130)
o Operatory relacji (131)
o Operatory logiczne (131)
o Operatory bitowe (132)
o Operatory przesunięć (133)
o Operatory jednoargumentowe (135)
o Operator trójargumentowy (136)
o Operator przecinkowy (137)
o Najczęstsze pułapki związane z używaniem operatorów (137)
o Operatory rzutowania (138)
o Jawne rzutowanie w C++ (139)
o sizeof - samotny operator (143)
o Słowo kluczowe asm (143)
o Operatory dosłowne (144)
* Tworzenie typów złożonych (144)
o Nadawanie typom nowych nazw za pomocą typedef (144)
o Łączenie zmiennych w struktury (145)
o Zwiększanie przejrzystości programów za pomocą wyliczeń (148)
o Oszczędzanie pamięci za pomocą unii (150)
o Tablice (151)
* Wskazówki dotyczące uruchamiania programów (159)
o Znaczniki uruchomieniowe (160)
o Przekształcanie zmiennych i wyrażeń w łańcuchy (162)
o Makroinstrukcja assert( ) języka C (162)
* Adresy funkcji (163)
o Definicja wskaźnika do funkcji (163)
o Skomplikowane deklaracje i definicje (164)
o Wykorzystywanie wskaźników do funkcji (165)
o Tablice wskaźników do funkcji (166)
* Make - zarządzanie rozłączną kompilacją (167)
o Działanie programu make (168)
o Pliki makefile używane w książce (171)
o Przykładowy plik makefile (171)
* Podsumowanie (173)
* Ćwiczenia (173)

Rozdział 4. Abstrakcja danych (179)

* Miniaturowa biblioteka w stylu C (180)
o Dynamiczny przydział pamięci (183)
o Błędne założenia (186)
* Na czym polega problem? (188)
* Podstawowy obiekt (188)
* Czym są obiekty? (194)
* Tworzenie abstrakcyjnych typów danych (195)
* Szczegóły dotyczące obiektów (196)
* Zasady używania plików nagłówkowych (197)
o Znaczenie plików nagłówkowych (198)
o Problem wielokrotnych deklaracji (199)
o Dyrektywy preprocesora #define, #ifdef i #endif (200)
o Standard plików nagłówkowych (201)
o Przestrzenie nazw w plikach nagłówkowych (202)
o Wykorzystywanie plików nagłówkowych w projektach (202)
* Zagnieżdżone struktury (202)
o Zasięg globalny (206)
* Podsumowanie (206)
* Ćwiczenia (207)

Rozdział 5. Ukrywanie implementacji (211)

* Określanie ograniczeń (211)
* Kontrola dostępu w C++ (212)
o Specyfikator protected (214)
* Przyjaciele (214)
o Zagnieżdżeni przyjaciele (216)
o Czy jest to "czyste"? (218)
* Struktura pamięci obiektów (219)
* Klasy (219)
o Modyfikacja programu Stash, wykorzystująca kontrolę dostępu (222)
o Modyfikacja stosu, wykorzystująca kontrolę dostępu (223)
* Klasy-uchwyty (223)
o Ukrywanie implementacji (224)
o Ograniczanie powtórnych kompilacji (224)
* Podsumowanie (226)
* Ćwiczenia (227)

Rozdział 6. Inicjalizacja i końcowe porządki (229)

* Konstruktor gwarantuje inicjalizację (230)
* Destruktor gwarantuje sprzątanie (232)
* Eliminacja bloku definicji (233)
o Pętle for (235)
o Przydzielanie pamięci (236)
* Klasa Stash z konstruktorami i destruktorami (237)
* Klasa Stack z konstruktorami i destruktorami (240)
* Inicjalizacja agregatowa (242)
* Konstruktory domyślne (245)
* Podsumowanie (246)
* Ćwiczenia (246)

Rozdział 7. Przeciążanie nazw funkcji i argumenty domyślne (249)

* Dalsze uzupełnienia nazw (250)
o Przeciążanie na podstawie zwracanych wartości (251)
o Łączenie bezpieczne dla typów (252)
* Przykładowe przeciążenie (253)
* Unie (255)
* Argumenty domyślne (258)
o Argumenty-wypełniacze (259)
* Przeciążanie kontra argumenty domyślne (260)
* Podsumowanie (264)
* Ćwiczenia (265)

Rozdział 8. Stałe (267)

* Podstawianie wartości (267)
o Stałe w plikach nagłówkowych (268)
o Bezpieczeństwo stałych (269)
o Agregaty (270)
o Różnice w stosunku do języka C (271)
* Wskaźniki (272)
o Wskaźniki do stałych (272)
o Stałe wskaźniki (273)
o Przypisanie a kontrola typów (274)
* Argumenty funkcji i zwracane wartości (275)
o Przekazywanie stałej przez wartość (275)
o Zwracanie stałej przez wartość (276)
o Przekazywanie i zwracanie adresów (279)
* Klasy (282)
o Stałe w klasach (282)
o Stałe o wartościach określonych podczas kompilacji, zawarte w klasach (285)
o Stałe obiekty i funkcje składowe (287)
* volatile (292)
* Podsumowanie (293)
* Ćwiczenia (294)

Rozdział 9. Funkcje inline (297)

* Pułapki preprocesora (298)
o Makroinstrukcje a dostęp (300)
* Funkcje inline (301)
o Funkcje inline wewnątrz klas (302)
o Funkcje udostępniające (303)
* Klasy Stash i Stack z funkcjami inline (308)
* Funkcje inline a kompilator (311)
o Ograniczenia (312)
o Odwołania do przodu (313)
o Działania ukryte w konstruktorach i destruktorach (313)
* Walka z bałaganem (314)
* Dodatkowe cechy preprocesora (315)
o Sklejanie symboli (316)
* Udoskonalona kontrola błędów (316)
* Podsumowanie (319)
* Ćwiczenia (320)

Rozdział 10. Zarządzanie nazwami (323)

* Statyczne elementy języka C (323)
o Zmienne statyczne znajdujące się wewnątrz funkcji (324)
o Sterowanie łączeniem (328)
o Inne specyfikatory klas pamięci (330)
* Przestrzenie nazw (330)
o Tworzenie przestrzeni nazw (330)
o Używanie przestrzeni nazw (332)
o Wykorzystywanie przestrzeni nazw (336)
* Statyczne składowe w C++ (337)
o Definiowanie pamięci dla statycznych danych składowych (337)
o Klasy zagnieżdżone i klasy lokalne (341)
o Statyczne funkcje składowe (342)
* Zależności przy inicjalizacji obiektów statycznych (344)
o Jak można temu zaradzić? (346)
* Specyfikacja zmiany sposobu łączenia (352)
* Podsumowanie (353)
* Ćwiczenia (353)

Rozdział 11. Referencje i konstruktor kopiujący (359)

* Wskaźniki w C++ (359)
* Referencje w C++ (360)
o Wykorzystanie referencji w funkcjach (361)
o Wskazówki dotyczące przekazywania argumentów (363)
* Konstruktor kopiujący (363)
o Przekazywanie i zwracanie przez wartość (364)
o Konstrukcja za pomocą konstruktora kopiującego (369)
o Domyślny konstruktor kopiujący (374)
o Możliwości zastąpienia konstruktora kopiującego (376)
* Wskaźniki do składowych (378)
o Funkcje (380)
* Podsumowanie (382)
* Ćwiczenia (383)

Rozdział 12. Przeciążanie operatorów (387)

* Ostrzeżenie i wyjaśnienie (387)
* Składnia (388)
* Operatory, które można przeciążać (389)
o Operatory jednoargumentowe (390)
o Operatory dwuargumentowe (393)
o Argumenty i zwracane wartości (402)
o Nietypowe operatory (405)
o Operatory, których nie można przeciążać (412)
* Operatory niebędące składowymi (413)
o Podstawowe wskazówki (414)
* Przeciążanie operacji przypisania (415)
o Zachowanie się operatora = (416)
* Automatyczna konwersja typów (425)
o Konwersja za pomocą konstruktora (425)
o Operator konwersji (427)
o Przykład konwersji typów (429)
o Pułapki automatycznej konwersji typów (430)
* Podsumowanie (432)
* Ćwiczenia (432)

Rozdział 13. Dynamiczne tworzenie obiektów (437)

* Tworzenie obiektów (438)
o Obsługa sterty w języku C (439)
o Operator new (440)
o Operator delete (441)
o Prosty przykład (442)
o Narzut menedżera pamięci (442)
* Zmiany w prezentowanych wcześniej przykładach (443)
o Usuwanie wskaźnika void* jest prawdopodobnie błędem (443)
o Odpowiedzialność za sprzątanie wskaźników (445)
o Klasa Stash przechowująca wskaźniki (445)
* Operatory new i delete dla tablic (450)
o Upodabnianie wskaźnika do tablicy (451)
* Brak pamięci (451)
* Przeciążanie operatorów new i delete (452)
o Przeciążanie globalnych operatorów new i delete (453)
o Przeciążanie operatorów new i delete w obrębie klasy (455)
o Przeciążanie operatorów new i delete w stosunku do tablic (458)
o Wywołania konstruktora (460)
o Operatory umieszczania new i delete (461)
* Podsumowanie (463)
* Ćwiczenia (463)

Rozdział 14. Dziedziczenie i kompozycja (467)

* Składnia kompozycji (468)
* Składnia dziedziczenia (469)
* Lista inicjatorów konstruktora (471)
o Inicjalizacja obiektów składowych (471)
o Typy wbudowane znajdujące się na liście inicjatorów (472)
* Łączenie kompozycji i dziedziczenia (473)
o Kolejność wywoływania konstruktorów i destruktorów (474)
* Ukrywanie nazw (476)
* Funkcje, które nie są automatycznie dziedziczone (480)
o Dziedziczenie a statyczne funkcje składowe (483)
* Wybór między kompozycją a dziedziczeniem (484)
o Tworzenie podtypów (485)
o Dziedziczenie prywatne (487)
* Specyfikator protected (488)
o Dziedziczenie chronione (489)
* Przeciążanie operatorów a dziedziczenie (490)
* Wielokrotne dziedziczenie (491)
* Programowanie przyrostowe (492)
* Rzutowanie w górę (492)
o Dlaczego "rzutowanie w górę"? (494)
o Rzutowanie w górę a konstruktor kopiujący (494)
o Kompozycja czy dziedziczenie (po raz drugi) (497)
o Rzutowanie w górę wskaźników i referencji (498)
o Kryzys (498)
* Podsumowanie (498)
* Ćwiczenia (499)

Rozdział 15. Polimorfizm i funkcje wirtualne (503)

* Ewolucja programistów języka C++ (504)
* Rzutowanie w górę (504)
* Problem (506)
o Wiązanie wywołania funkcji (506)
* Funkcje wirtualne (506)
o Rozszerzalność (508)
* W jaki sposób język C++ realizuje późne wiązanie? (510)
o Przechowywanie informacji o typie (511)
o Obraz funkcji wirtualnych (512)
o Rzut oka pod maskę (514)
o Instalacja wskaźnika wirtualnego (515)
o Obiekty są inne (516)
* Dlaczego funkcje wirtualne? (517)
* Abstrakcyjne klasy podstawowe i funkcje czysto wirtualne (518)
o Czysto wirtualne definicje (522)
* Dziedziczenie i tablica VTABLE (523)
o Okrajanie obiektów (525)
* Przeciążanie i zasłanianie (527)
o Zmiana typu zwracanej wartości (529)
* Funkcje wirtualne a konstruktory (530)
o Kolejność wywoływania konstruktorów (531)
o Wywoływanie funkcji wirtualnych wewnątrz konstruktorów (532)
* Destruktory i wirtualne destruktory (533)
o Czysto wirtualne destruktory (535)
o Wirtualne wywołania w destruktorach (537)
o Tworzenie hierarchii bazującej na obiekcie (538)
* Przeciążanie operatorów (541)
* Rzutowanie w dół (543)
* Podsumowanie (546)
* Ćwiczenia (546)

Rozdział 16. Wprowadzenie do szablonów (551)

* Kontenery (551)
o Potrzeba istnienia kontenerów (553)
* Podstawy szablonów (554)
o Rozwiązanie z wykorzystaniem szablonów (556)
* Składnia szablonów (558)
o Definicje funkcji niebędących funkcjami inline (559)
o Klasa IntStack jako szablon (560)
o Stałe w szablonach (562)
* Klasy Stack i Stash jako szablony (563)
o Kontener wskaźników Stash, wykorzystujący szablony (565)
* Przydzielanie i odbieranie prawa własności (570)
* Przechowywanie obiektów jako wartości (573)
* Wprowadzenie do iteratorów (575)
o Klasa Stack z iteratorami (582)
o Klasa PStash z iteratorami (585)
* Dlaczego iteratory? (590)
o Szablony funkcji (593)
* Podsumowanie (594)
* Ćwiczenia (594)

Dodatek A Styl kodowania (599)

Dodatek B Wskazówki dla programistów (609)

Dodatek C Zalecana literatura (621)

* Język C (621)
* Ogólnie o języku C++ (621)
o Książki, które napisałem (622)
* Głębia i mroczne zaułki (623)
* Analiza i projektowanie (623)