Spis treści

C++ dla każdego -- spis treści

O Autorze (15)

Wstęp (17)

Część I (19)

Rozdział 1. Zaczynamy (21)

• Wprowadzenie (21)
  
• Krótka historia języka C++ (21)
  
  • Rozwiązywanie problemów (22)
  • Programowanie proceduralne, strukturalne i obiektowe (23)
  • C++ i programowanie zorientowane obiektowo (25)
• Jak ewoluowało C++ (26)
  
• Czy należy najpierw poznać C? (26)
  
• C++ a Java i C# (27)
  
• Standard ANSI (27)
  
• Przygotowanie do programowania (28)
  
• Twoje środowisko programowania (28)
  
• Tworzenie programu (29)
  
  • Tworzenie pliku obiektowego za pomocą kompilatora (29)
  • Tworzenie pliku wykonywalnego za pomocą linkera (30)
• Cykl tworzenia programu (30)
  
• HELLO.cpp - twój pierwszy program w C++ (32)
  
• Zaczynamy pracę z kompilatorem (34)
  
  • Budowanie projektu Hello World (34)
• Błędy kompilacji (36)

Rozdział 2. Anatomia programu C++ (37)

• Prosty program (37)
  
• Rzut oka na obiekt cout (39)
  
• Używanie przestrzeni nazw standardowych (41)
  
• Komentarze (43)
  
  • Rodzaje komentarzy (44)
  • Używanie komentarzy (44)
  • Jeszcze jedna uwaga na temat komentarzy (45)
• Funkcje (45)
  
  • Korzystanie z funkcji (46)

Rozdział 3. Zmienne i stałe (49)

• Czym jest zmienna? (49)
  
  • Dane są przechowywane w pamięci (49)
  • Przydzielanie pamięci (50)
  • Rozmiar liczb całkowitych (51)
  • Zapis ze znakiem i bez znaku (52)
  • Podstawowe typy zmiennych (53)
• Definiowanie zmiennej (54)
  
  • Uwzględnianie wielkości liter (55)
  • Słowa kluczowe (56)
• Tworzenie kilku zmienych jednocześnie (56)
  
• Przypisywanie zmiennym wartości (56)
  
• typedef (58)
  
• Kiedy używać typu short, a kiedy typu long? (59)
  
  • Zawinięcie liczby całkowitej bez znaku (60)
  • Zawinięcie liczby całkowitej ze znakiem (61)
• Znaki (62)
  
  • Znaki i liczby (62)
  • Znaki specjalne (63)
• Stałe (64)
  
  • Literały (64)
  • Stałe symboliczne (64)
• Stałe wyliczeniowe (66)

Rozdział 4. Wyrażenia i instrukcje (69)

• Instrukcje (69)
  
  • Białe spacje (70)
  • Bloki i instrukcje złożone (70)
• Wyrażenia (70)
  
• Operatory (72)
  
  • Operator przypisania (72)
  • Operatory matematyczne (73)
  • Dzielenie całkowite i reszta z dzielenia (73)
• Łączenie operatora przypisania z operatorem matematycznym (74)
  
• Inkrementacja i dekrementacja (75)
  
  • Przedrostki i przyrostki (75)
• Kolejność działań (77)
  
• Zagnieżdżanie nawiasów (78)
  
• Prawda i fałsz (79)
  
  • Operatory relacji (79)
• Instrukcja if (80)
  
  • Styl wcięć (83)
  • else (84)
  • Zaawansowane instrukcje if (86)
• Użycie nawiasów klamrowych w zagnieżdżonych instrukcjach if (87)
  
• Operatory logiczne (89)
  
  • Logiczne I (90)
  • Logiczne LUB (90)
  • Logiczne NIE (90)
• Skrócone obliczanie wyrażeń logicznych (91)
  
• Kolejność operatorów logicznych (91)
  
• Kilka słów na temat prawdy i fałszu (92)
  
• Operator warunkowy (trójelementowy) (93)

Rozdział 5. Funkcje (95)

• Czym jest funkcja? (95)
  
• Zwracane wartości, parametry i argumenty (96)
  
• Deklarowanie i definiowanie funkcji (97)
  
  • Deklarowanie funkcji (97)
  • Prototypy funkcji (98)
  • Definiowanie funkcji (99)
• Wykonywanie funkcji (100)
  
• Zmienne lokalne (101)
  
  • Zakres (102)
• Zmienne globalne (102)
  
• Zmienne globalne: ostrzeżenie (104)
  
• Kilka słów na temat zmiennych lokalnych (104)
  
• Instrukcje funkcji (106)
  
• Kilka słów na temat argumentów funkcji (106)
  
  • Użycie funkcji jako parametrów funkcji (106)
• Parametry są zmiennymi lokalnymi (107)
  
• Kilka słów na temat zwracanych wartości (109)
  
• Parametry domyślne (111)
  
• Przeciążanie funkcji (113)
  
• Zagadnienia związane z funkcjami (116)
  
  • Funkcje typu inline (116)
  • Rekurencja (118)
• Jak działają funkcje - rzut oka "pod maskę" (123)
  
  • Poziomy abstrakcji (123)
  • Podział pamięci (123)
  • Stos i funkcje (126)

Rozdział 6. Programowanie zorientowane obiektowo (129)

• Czy C++ jest zorientowane obiektowo? (129)
  
• Tworzenie nowych typów (130)
  
  • Po co tworzyć nowy typ? (131)
• Klasy i składowe (131)
  
  • Deklarowanie klasy (132)
  • Kilka słów o konwencji nazw (132)
  • Definiowanie obiektu (133)
  • Klasy a obiekty (133)
• Dostęp do składowych klasy (134)
  
  • Przypisywać należy obiektom, nie klasom (134)
  • Czego nie zadeklarujesz, tego klasa nie będzie miała (134)
• Prywatne i publiczne (135)
  
  • Oznaczanie danych składowych jako prywatnych (137)
  • Prywatność a ochrona (138)
• Implementowanie metod klasy (140)
  
• Konstruktory i destruktory (142)
  
  • Domyślne konstruktory i destruktory (143)
  • Użycie domyślnego konstruktora (143)
• Funkcje składowe const (146)
  
• Interfejs a implementacja (147)
  
• Gdzie umieszczać deklaracje klasy i definicje metod (150)
  
• Implementacja inline (151)
  
• Klasy, których danymi składowymi są inne klasy (153)
  
• Struktury (157)
  
  • Dlaczego dwa słowa kluczowe spełniają tę samą funkcję (157)

Rozdział 7. Sterowanie przebiegiem działania programu (159)

• Pętle (159)
  
  • Początki pętli: instrukcja goto (159)
  • Dlaczego nie jest zalecane stosowanie instrukcji goto? (160)
• Pętle while (160)
  
  • Bardziej skomplikowane instrukcje while (162)
  • continue oraz break (163)
  • Pętla while (true) (166)
• Pętla do...while (167)
  
• do...while (168)
  
• Pętle for (170)
  
  • Zaawansowane pętle for (171)
  • Puste pętle for (174)
  • Pętle zagnieżdżone (175)
  • Zakres zmiennych w pętlach for (177)
• Podsumowanie pętli (178)
  
• Instrukcja switch (180)
  
  • Użycie instrukcji switch w menu (182)
• Program podsumowujący wiadomości (186)

Część II (191)

Rozdział 8. Wskaźniki (193)

• Czym jest wskaźnik? (193)
  
  • Kilka słów na temat pamięci (193)
  • Użycie operatora adresu (&) (194)
  • Przechowywanie adresu we wskaźniku (195)
  • Puste i błędne wskaźniki (195)
  • Nazwy wskaźników (196)
  • Operator wyłuskania (197)
  • Wskaźniki, adresy i zmienne (197)
  • Operowanie danymi poprzez wskaźniki (199)
  • Sprawdzanie adresu (200)
• Do czego służą wskaźniki? (202)
  
• Stos i sterta (203)
  
  • Operator new (204)
  • delete (204)
• Wycieki pamięci (206)
  
• Tworzenie obiektów na stercie (207)
  
• Usuwanie obiektów (207)
  
• Dostęp do składowych klasy (208)
  
• Dane składowe na stercie (210)
  
• Wskaźnik this (212)
  
• Utracone wskaźniki (214)
  
• Wskaźniki const (217)
  
  • Wskaźniki const i funkcje składowe const (218)
  • Wskaźniki const this (219)
• Działania arytmetyczne na wskaźnikach - temat dla zaawansowanych (220)

Rozdział 9. Referencje (223)

• Czym jest referencja? (223)
  
• Użycie operatora adresu z referencją (225)
  
  • Nie można zmieniać przypisania referencji (226)
• Do czego mogą odnosić się referencje? (227)
  
• Zerowe wskaźniki i zerowe referencje (229)
  
• Przekazywanie argumentów funkcji przez referencję (229)
  
  • Tworzenie funkcji swap() otrzymującej wskaźniki (231)
  • Implementacja funkcji swap() za pomocą referencji (233)
• Nagłówki i prototypy funkcji (234)
  
• Zwracanie kilku wartości (235)
  
  • Zwracanie wartości przez referencję (237)
• Przekazywanie przez referencję zwiększa efektywność działania programu (238)
  
  • Przekazywanie wskaźnika const (241)
  • Referencje jako metoda alternatywna (243)
• Kiedy używać wskaźników, a kiedy referencji (245)
  
• Łączenie referencji i wskaźników (246)
  
• Nie pozwól funkcji zwracać referencji do obiektu, którego nie ma w zakresie! (247)
  
• Zwracanie referencji do obiektu na stercie (249)
  
• Wskaźnik, wskaźnik, kto ma wskaźnik? (251)

Rozdział 10. Funkcje zaawansowane (253)

• Przeciążone funkcje składowe (253)
  
• Użycie wartości domyślnych (255)
  
• Wybór pomiędzy wartościami domyślnymi a przeciążaniem funkcji (257)
  
• Konstruktor domyślny (258)
  
• Przeciążanie konstruktorów (258)
  
• Inicjalizowanie obiektów (260)
  
• Konstruktor kopiujący (261)
  
• Przeciążanie operatorów (265)
  
  • Pisanie funkcji inkrementacji (266)
  • Przeciążanie operatora przedrostkowego (267)
  • Zwracanie typów w przeciążonych funkcjach operatorów (268)
  • Zwracanie obiektów tymczasowych bez nadawania im nazw (270)
  • Użycie wskaźnika this (271)
  • Dlaczego stała referencja? (273)
  • Przeciążanie operatora przyrostkowego (273)
  • Różnica pomiędzy przedrostkiem a przyrostkiem (273)
  • Operator dodawania (275)
  • Przeciążanie operatora dodawania (277)
  • Zagadnienia związane z przeciążaniem operatorów (278)
  • Ograniczenia w przeciążaniu operatorów (278)
  • Co przeciążać? (279)
  • Operator przypisania (279)
• Obsługa konwersji typów danych (282)
  
  • Operatory konwersji (285)

Rozdział 11. Analiza i projektowanie zorientowane obiektowo (287)

• Budowanie modeli (287)
  
• Projektowanie oprogramowania: język modelowania (288)
  
• Projektowanie oprogramowania: proces (289)
  
• Programowanie ekstremalne (292)
  
• Pomysł (292)
  
• Analiza wymagań (293)
  
  • Przypadki użycia (293)
  • Analiza aplikacji (303)
  • Analiza systemów (304)
  • Tworzenie dokumentacji (304)
  • Wizualizacje (305)
  • Dokumentacja produktu (305)
• Projektowanie (306)
  
  • Czym są klasy? (306)
  • Przekształcenia (308)
  • Model statyczny (309)
  • Model dynamiczny (318)

Rozdział 12. Dziedziczenie (321)

• Czym jest dziedziczenie? (321)
  
  • Dziedziczenie i wyprowadzanie (322)
  • Królestwo zwierząt (323)
  • Składnia wyprowadzania (323)
• Prywatne kontra chronione (325)
  
• Konstruktory i destruktory (327)
  
  • Przekazywanie argumentów do konstruktorów bazowych (329)
• Przesłanianie funkcji (333)
  
  • Ukrywanie metod klasy bazowej (335)
  • Wywoływanie metod klasy bazowej (337)
• Metody wirtualne (338)
  
  • Jak działają funkcje wirtualne (342)
  • Nie możesz przejść stąd dotąd (343)
  • Okrajanie (344)
  • Destruktory wirtualne (346)
  • Wirtualne konstruktory kopiujące (346)
  • Koszt metod wirtualnych (349)

Rozdział 13. Tablice i listy połączone (351)

• Czym jest tablica? (351)
  
• Elementy tablicy (352)
  
• Zapisywanie za końcem tablicy (353)
  
• Błąd słupka w płocie (356)
  
• Inicjalizowanie tablic (356)
  
• Deklarowanie tablic (357)
  
• Tablice obiektów (358)
  
• Tablice wielowymiarowe (360)
  
• Inicjalizowanie tablic wielowymiarowych (360)
  
• Kilka słów na temat pamięci (362)
  
• Tablice wskaźników (363)
  
• Deklarowane tablic na stercie (364)
  
• Wskaźnik do tablicy a tablica wskaźników (365)
  
• Wskaźniki a nazwy tablic (365)
  
• Usuwanie tablic ze sterty (367)
  
• Tablice znaków (368)
  
• strcpy() oraz strncpy() (370)
  
• Klasy łańcuchów (371)
  
• Listy połączone i inne struktury (378)
  
• Analiza listy połączonej (378)
  
  • Przeniesienie odpowiedzialności (379)
• Części składowe (379)
  
• Czego się nauczyłaś, Dorotko? (388)
  
• Klasy tablic (388)

Rozdział 14. Polimorfizm (391)

• Problemy z pojedynczym dziedziczeniem (391)
  
  • Przenoszenie w górę (394)
  • Rzutowanie w dół (394)
  • Połączenie dwóch list (397)
• Dziedziczenie wielokrotne (397)
  
  • Części obiektu z dziedziczeniem wielokrotnym (400)
  • Konstruktory w obiektach dziedziczonych wielokrotnie (401)
  • Eliminowanie niejednoznaczności (403)
  • Dziedziczenie ze wspólnej klasy bazowej (404)
  • Dziedziczenie wirtualne (408)
  • Problemy z dziedziczeniem wielokrotnym (411)
  • Mixiny i klasy metod (412)
• Abstrakcyjne typy danych (413)
  
  • Czyste funkcje wirtualne (416)
  • Implementowanie czystych funkcji wirtualnych (417)
  • Złożone hierarchie abstrakcji (420)
  • Które typy są abstrakcyjne? (424)
• Program podsumowujący wiadomości (425)

Część III (435)

Rozdział 15. Specjalne klasy i funkcje (437)

• Statyczne dane składowe (437)
  
• Statyczne funkcje składowe (442)
  
• Wskaźniki do funkcji (444)
  
  • Dlaczego warto używać wskaźników do funkcji? (447)
  • Tablice wskaźników do funkcji (450)
  • Przekazywanie wskaźników do funkcji innym funkcjom (452)
  • Użycie instrukcji typedef ze wskaźnikami do funkcji (455)
• Wskaźniki do funkcji składowych (457)
  
  • Tablice wskaźników do funkcji składowych (459)

Rozdział 16. Dziedziczenie zaawansowane (463)

• Zawieranie (463)
  
  • Dostęp do składowych klasy zawieranej (469)
  • Filtrowany dostęp do składowych zawieranych (469)
  • Koszt zawierania (470)
  • Kopiowanie przez wartość (473)
• Implementowanie poprzez dziedziczenie i zawieranie oraz poprzez delegację (476)
  
  • Delegacja (477)
• Dziedziczenie prywatne (485)
  
• Klasy zaprzyjaźnione (493)
  
• Funkcje zaprzyjaźnione (501)
  
• Funkcje zaprzyjaźnione i przeciążanie operatorów (501)
  
• Przeciążanie operatora wstawiania (505)

Rozdział 17. Strumienie (511)

• Przegląd strumieni (511)
  
  • Kapsułkowanie (512)
  • Buforowanie (512)
• Strumienie i bufory (514)
  
• Standardowe obiekty wejścia-wyjścia (514)
  
• Przekierowywanie (515)
  
• Wejście z użyciem cin (516)
  
  • Łańcuchy (517)
  • Problemy z łańcuchami (517)
  • Zwracanie referencji do obiektu istream przez operator>> (520)
• Inne funkcje składowe w dyspozycji cin (520)
  
  • Wprowadzanie pojedynczych znaków (521)
  • Odczytywanie łańcuchów z wejścia standardowego (523)
  • Użycie cin.ignore() (526)
  • peek() oraz putback() (527)
• Wyjście poprzez cout (528)
  
  • Zrzucanie zawartości bufora (528)
• Powiązane funkcje (528)
  
• Manipulatory, znaczniki oraz instrukcje formatowania (530)
  
  • Użycie cout.width() (530)
  • Ustawianie znaków wypełnienia (531)
  • Funkcja setf() (532)
• Strumienie kontra funkcja printf() (534)
  
• Wejście i wyjście z użyciem plików (537)
  
• ofstream (538)
  
  • Stany strumieni (538)
  • Otwieranie plików dla wejścia i wyjścia (538)
  • Zmiana domyślnego zachowania obiektu ofstream w trakcie otwierania pliku (540)
• Pliki binarne a pliki tekstowe (542)
  
• Przetwarzanie linii polecenia (544)

Rozdział 18. Przestrzenie nazw (549)

• Zaczynamy (549)
  
• Funkcje i klasy są rozpoznawane poprzez nazwy (550)
  
• Tworzenie przestrzeni nazw (553)
  
  • Deklarowanie i definiowanie typów (554)
  • Definiowanie funkcji poza przestrzenią nazw (554)
  • Dodawanie nowych składowych (555)
  • Zagnieżdżanie przestrzeni nazw (555)
• Używanie przestrzeni nazw (556)
  
• Słowo kluczowe using (558)
  
  • Dyrektywa using (558)
  • Deklaracja using (559)
• Alias przestrzeni nazw (561)
  
• Nienazwana przestrzeń nazw (561)
  
• Standardowa przestrzeń nazw std (562)

Rozdział 19. Wzorce (565)

• Czym są wzorce? (565)
  
• Typy parametryzowane (566)
  
  • Tworzenie egzemplarza wzorca (566)
• Definicja wzorca (566)
  
  • Użycie nazwy (568)
  • Implementowanie wzorca (568)
• Funkcje wzorcowe (571)
  
• Wzorce i przyjaciele (572)
  
  • Niewzorcowe zaprzyjaźnione klasy i funkcje (572)
  • Ogólne wzorcowe zaprzyjaźnione klasy i funkcje (575)
• Użycie elementów wzorca (579)
  
  • Funkcje specjalizowane (582)
  • Wzorce i składowe statyczne (588)
• Standardowa biblioteka wzorców (591)
  
• Kontenery (591)
  
• Kontenery sekwencyjne (592)
  
  • Kontener vector (592)
  • Kontener list (598)
  • Kontener deque (599)
• Stosy (600)
  
• Kolejki (601)
  
• Kontenery asocjacyjne (601)
  
  • Kontener map (601)
  • Inne kontenery asocjacyjne (604)
• Klasy algorytmów (604)
  
  • Bezmutacyjne operacje sekwencyjne (605)
  • Mutacyjne algorytmy sekwencyjne (606)

Rozdział 20. Wyjątki i obsługa błędów (609)

• Pluskwy, błędy, pomyłki i "psujący" się kod (609)
  
  • Wyjątki (610)
• Wyjątki (611)
  
  • Jak używane są wyjątki (611)
• Użycie bloków try oraz bloków catch (616)
  
  • Wychwytywanie wyjątków (616)
  • Wychwytywanie więcej niż jednego rodzaju wyjątków (617)
  • Hierarchie wyjątków (620)
• Dane w wyjątkach oraz nazwane obiekty wyjątków (622)
  
• Wyjątki i wzorce (629)
  
• Wyjątki bez błędów (631)
  
• Kilka słów na temat "psującego" się kodu (632)
  
• Pluskwy i odpluskwianie (633)
  
  • Punkty wstrzymania (633)
  • Śledzenie wartości zmiennych (633)
  • Sprawdzanie pamięci (634)
  • Asembler (634)

Rozdział 21. Co dalej (635)

• Preprocesor i kompilator (635)
  
• Przeglądanie formy pośredniej (636)
  
• Użycie dyrektywy #define (636)
  
  • Użycie #define dla stałych (636)
  • Użycie #define do definiowania symboli (636)
  • Dyrektywa #else preprocesora (637)
• Dołączanie i wartowniki dołączania (638)
  
• Funkcje makro (640)
  
  • Po co te wszystkie nawiasy? (641)
  • Makra a funkcje i wzorce (642)
• Funkcje inline (642)
  
• Manipulacje łańcuchami (644)
  
  • Zamiana w łańcuch (644)
  • Konkatenacja (644)
• Makra predefiniowane (645)
  
• Makro assert() (645)
  
  • Debuggowanie za pomocą makra assert() (647)
  • Makro assert() a wyjątki (647)
  • Efekty uboczne (648)
  • Niezmienniki klas (648)
  • Wypisywanie wartości tymczasowych (653)
  • Poziomy debuggowania (654)
• Operacje na bitach (660)
  
  • Operator AND (661)
  • Operator OR (661)
  • Operator XOR (661)
  • Operator negacji (661)
  • Ustawianie bitów (661)
  • Zerowanie bitów (662)
  • Zmiana stanu bitów na przeciwny (662)
  • Pola bitowe (663)
• Styl (666)
  
  • Wcięcia (666)
  • Nawiasy klamrowe (666)
  • Długość linii (666)
  • Instrukcje switch (667)
  • Tekst programu (667)
  • Nazwy identyfikatorów (668)
  • Komentarze (669)
  • Dostęp (670)
  • Definicje klas (670)
  • Dołączanie plików (670)
  • assert() (671)
  • const (671)
• Następne kroki (671)
  
  • Gdzie uzyskać pomoc i poradę (671)
  • Przejść do C#? (672)
  • Bądź w kontakcie (672)
• Program podsumowujący wiadomości (672)

Dodatki (683)

Dodatek A Dwójkowo i szesnastkowo (685)

• Inne podstawy (686)
  
• Wokół podstaw (686)
  
  • Dwójkowo (688)
  • Dlaczego podstawa 2? (689)
  • Bity, bajty, nible (689)
  • Co to jest KB? (690)
  • Liczby dwójkowe (690)
• Szesnastkowo (691)

Dodatek B Słowa kluczowe C++ (695)

Dodatek C Kolejność operatorów (697)

Skorowidz (699)