Wstęp (13)

• Po co nowa książka o języku C++? (13)
  
• Co nowego jest jeszcze w tej książce? (14)
  
• Wiele ścieżek nauczania. Co jest dla Ciebie najlepsze? (15)
  
• A co, jeśli masz już pewne podstawowe wiadomości na temat programowania? (16)
  
• Czego w tej książce nie ma? (16)
  
• Dlaczego warto zaczynać naukę języka C++? (17)
  
• Aby rozpocząć... (18)
  
• Sztuczki i chwyty. Na co powinieneś uważać? (19)

Rozdział 1. Twoje pierwsze programy w C++ (21)

• Myśleć jak programista (21)
  
  • Komputery robią tylko to, co im każesz (21)
  • Określanie, co ma robić program (22)
  • Pisanie odpowiednich wyrażeń C++ (23)
  • Przegląd kilku specjalistycznych definicji (24)
• Co wyróżnia język C++? (27)
  
  • Ciekawostka - Co z Javą i C#? (28)
• Tworzenie programu w języku C++ (29)
  
  • Wprowadzanie wyrażeń tworzących program (30)
  • Budowanie programu (kompilowanie i łączenie) (30)
  • Testowanie programu (31)
  • Poprawianie w miarę potrzeby (32)
• Instalowanie Twojego własnego kompilatora (33)
  
• Przykład 1.1. Wyświetlanie komunikatu (33)
  
  • Jeśli używasz środowiska RHIDE (34)
  • Jeśli używasz Microsoft Visual Studio (35)
  • Jak to działa? (36)
  • Ćwiczenia (37)
    • Ciekawostka - Co z wyrażeniami #include i using? (38)
• Przechodzenie do kolejnej linii wyświetlania (39)
  
• Przykład 1.2. Wyświetlanie wielu linii (39)
  
  • Jak to działa? (40)
  • Ćwiczenia (41)
    • Ciekawostka - Co to jest łańcuch tekstowy? (42)
• Przechowywanie danych - zmienne w C++ (42)
  
• Wprowadzenie do typów danych (44)
  
  • Ciekawostka - Dlaczego podwójna precyzja zamiast pojedynczej? (45)
• Przykład 1.3. Konwertowanie temperatur (46)
  
  • Jak to działa? (47)
  • Wariacje na temat przykładu (49)
  • Ćwiczenia (51)
• Słowo na temat nazw zmiennych i słów kluczowych (51)
  
  • Ćwiczenie (52)
• Podsumowanie rozdziału 1. (52)

Rozdział 2. Decyzje, decyzje (55)

• Najpierw jednak kilka słów na temat typów danych (55)
  
  • Ciekawostka - Dla programistów znających C (59)
• Podejmowanie decyzji w programach (59)
  
• Instrukcje if oraz if-else (60)
  
  • Ciekawostka - Po co dwa operatory (= i ==)? (62)
• Przykład 2.1. Nieparzysty czy parzysty? (63)
  
  • Jak to działa? (64)
  • Optymalizowanie programu (65)
  • Ćwiczenie (66)
• Podstawy działania pętli (66)
  
  • Ciekawostka - Nieskończone zapętlenie (70)
• Przykład 2.2. Wyświetlanie liczb od 1 do N (70)
  
  • Jak to działa? (71)
  • Ćwiczenia (72)
• Prawda i fałsz w C++ (72)
  
  • Ciekawostka - Typ danych bool (73)
• Operator inkrementacji (++) (74)
  
• Polecenia kontra wyrażenia (75)
  
• Wprowadzenie do algebry Boole'a (układów logicznych) (76)
  
  • Ciekawostka - Czym jest wartość "prawda" ("true")? (78)
• Przykład 2.3. Sprawdzanie wieku ludzi (78)
  
  • Jak to działa? (79)
  • Ćwiczenie (79)
• Wprowadzenie do biblioteki math (79)
  
• Przykład 2.4. Sprawdzanie, czy wartość jest liczbą pierwszą (80)
  
  • Jak to działa? (82)
  • Optymalizowanie programu (83)
  • Ćwiczenie (83)
• Podsumowanie rozdziału 2. (84)

Rozdział 3. Wygodna i wszechstronna instrukcja for (87)

• Pętle opracowane w celu zliczania (88)
  
• Wprowadzenie do pętli for (89)
  
• Worek z przykładami (90)
  
  • Ciekawostka - Czy pętla for zawsze zachowuje się tak samo jak while? (91)
• Przykład 3.1. Wyświetlanie kolejnych liczb naturalnych od 1 do N przy użyciu pętli for (92)
  
  • Jak to działa? (92)
  • Ćwiczenie (93)
• Bloki poleceń w pętli for (93)
  
• Deklarowanie zmiennych sterujących pętlą "w locie" (94)
  
• Przykład 3.2. Sprawdzanie, czy wartość jest liczbą pierwszą, z wykorzystaniem pętli for (95)
  
  • Jak to działa? (96)
  • Ćwiczenie (98)
• Porównanie języków - instrukcja for w języku Basic (99)
  
• Podsumowanie rozdziału 3. (100)

Rozdział 4. Funkcje - wiele jest wywoływanych (103)

• Pojęcie funkcji (103)
  
• Wywołania funkcji i przepływ sterowania w programie (105)
  
• Podstawy korzystania z funkcji (107)
  
  • Krok pierwszy: deklaracja (prototyp) funkcji (108)
  • Krok drugi: definicja funkcji (109)
  • Krok trzeci: wywołanie funkcji (110)
• Przykład 4.1. Funkcja wyznaczająca liczbę trójkątną (111)
  
  • Jak to działa? (112)
  • Optymalizowanie programu (113)
  • Ćwiczenia (114)
• Przykład 4.2. Funkcja sprawdzająca, czy podana wartość jest liczbą pierwszą (115)
  
  • Jak to działa? (116)
  • Ćwiczenia (118)
• Zmienne lokalne i globalne (118)
  
• Funkcje rekurencyjne (120)
  
• Przykład 4.3. Największy wspólny dzielnik (NWD) (121)
  
  • Jak to działa? (124)
  • Ćwiczenia (125)
• Przykład 4.4. Rozkładanie liczb na czynniki pierwsze (125)
  
  • Jak to działa? (127)
    • Ciekawostka - Dla matematycznych oszołomów (129)
  • Ćwiczenia (130)
• Przykład 4.5. Generator liczb losowych (130)
  
  • Jak to działa? (131)
  • Ćwiczenie (133)
• Podsumowanie rozdziału 4. (133)

Rozdział 5. Tablice - znamy ich liczbę (135)

• Pierwsze spojrzenie na tablice w języku C++ (135)
  
• Inicjalizowanie tablic (137)
  
• Indeksowanie rozpoczynające się od zera (138)
  
  • Ciekawostka - Dlaczego używać indeksów rozpoczynających się od zera? (139)
• Przykład 5.1. Wyświetlanie elementów (139)
  
  • Jak to działa? (140)
  • Ćwiczenia (141)
• Przykład 5.2. Jak bardzo losowe są liczby losowe? (141)
  
  • Jak to działa? (144)
  • Ćwiczenia (145)
• Łańcuchy znakowe i tablice łańcuchów znakowych (146)
  
• Przykład 5.3. Krupier nr 1 (147)
  
  • Jak to działa? (149)
  • Ćwiczenie (150)
• Przykład 5.4. Krupier nr 2 (150)
  
  • Jak to działa? (151)
  • Ćwiczenie (153)
• Przykład 5.5. Krupier nr 3 (153)
  
  • Jak to działa? (155)
  • Optymalizowanie programu (156)
  • Ćwiczenie (157)
• Słowo do dociekliwych (158)
  
• Tablice dwuwymiarowe - witamy w świecie macierzy (159)
  
• Podsumowanie rozdziału 5. (160)

Rozdział 6. Wskaźniki - sposób na uchwycenie danych (163)

• Pojęcie wskaźnika (164)
  
  • Ciekawostka - Jak naprawdę wyglądają adresy? (165)
• Deklarowanie i używanie wskaźników (167)
  
• Przykład 6.1. Funkcja podwajająca (169)
  
  • Jak to działa? (170)
  • Ćwiczenia (172)
• Zamiana wartości, czyli kolejna funkcja wykorzystująca wskaźniki (172)
  
• Przykład 6.2. Program sortujący zawartość tablicy (174)
  
  • Jak to działa? (177)
  • Ćwiczenia (179)
• Arytmetyka wskaźników (179)
  
• Wskaźniki i przetwarzanie elementów tablic (182)
  
• Przykład 6.3. Zerowanie elementów tablicy (184)
  
  • Jak to działa? (184)
  • Optymalizowanie programu (185)
  • Ćwiczenia (187)
• Podsumowanie rozdziału 6. (187)

Rozdział 7. Łańcuchy znakowe - analizowanie tekstu (189)

• Przechowywanie tekstu na komputerze (190)
  
  • Ciekawostka - W jaki sposób komputer tłumaczy kody programów? (190)
• Mam tekst, czy go nie mam? (192)
  
• Funkcje pozwalające na działania na łańcuchach znakowych (193)
  
• Przykład 7.1. Budowanie łańcuchów znakowych (195)
  
  • Jak to działa? (196)
  • Ćwiczenia (198)
    • Ciekawostka - Co z tymi sekwencjami specjalnymi? (198)
• Pobieranie tekstu z wejścia (199)
  
• Przykład 7.2. Pobieranie liczby (202)
  
  • Jak to działa? (203)
  • Ćwiczenie (204)
• Przykład 7.3. Konwertowanie tekstów na wielkie litery (204)
  
  • Jak to działa? (205)
  • Ćwiczenia (206)
• Pojedyncze znaki kontra łańcuchy znakowe (206)
  
• Przykład 7.4. Analizowanie danych wejściowych (208)
  
  • Jak to działa? (209)
  • Ćwiczenia (212)
• Nowa klasa łańcuchów znakowych w C++ (213)
  
  • Zapewnienie możliwości obsługi klasy string (214)
  • Deklarowanie i inicjalizowanie zmiennych typu string (215)
  • Korzystanie ze zmiennych typu string (215)
  • Wejście i wyjście (217)
• Przykład 7.5. Budowanie łańcuchów znakowych za pomocą zmiennych typu string (217)
  
  • Jak to działa? (218)
  • Ćwiczenia (219)
• Inne operacje na danych typu string (219)
  
• Podsumowanie rozdziału 7. (221)

Rozdział 8. Pliki - elektroniczne magazyny (225)

• Wprowadzenie do obiektów strumieni plików (226)
  
• Jak odwoływać się do plików na dysku? (228)
  
• Przykład 8.1. Zapisywanie tekstu w pliku (229)
  
  • Jak to działa? (230)
  • Ćwiczenia (231)
• Przykład 8.2. Wyświetlanie zawartości pliku tekstowego (232)
  
  • Jak to działa? (233)
  • Ćwiczenia (234)
• Pliki tekstowe kontra pliki "binarne" (234)
  
  • Ciekawostka - Czy pliki "binarne" są w rzeczywistości bardziej binarne od tekstowych? (237)
• Wprowadzenie do operacji binarnych (238)
  
• Przykład 8.3. Bezpośredni zapis danych do pliku (240)
  
  • Jak to działa? (242)
  • Ćwiczenia (243)
• Przykład 8.4. Bezpośredni odczyt danych z pliku (243)
  
  • Jak to działa? (245)
  • Ćwiczenia (245)
• Podsumowanie rozdziału 8. (246)

Rozdział 9. Niektóre z zaawansowanych technik programistycznych (249)

• Argumenty linii poleceń (250)
  
• Przykład 9.1. Wyświetlanie zawartości pliku o nazwie podanej w linii poleceń (251)
  
  • Jak to działa? (253)
  • Ćwiczenia (253)
• Przeładowanie funkcji (254)
  
  • Ciekawostka - Przeładowanie i OOPS (255)
• Przykład 9.2. Wyświetlanie różnych rodzajów tablic (256)
  
  • Jak to działa? (257)
  • Ćwiczenie (258)
• Pętla do-while (258)
  
• Wyrażenie switch-case (260)
  
• Korzystanie z wielu modułów (261)
  
• Obsługa wyjątków (265)
  
  • Wyjątkom powiedz: "Dzień dobry!" (265)
  • Obsługa wyjątków: próba pierwsza (266)
  • Wprowadzenie do obsługi wyjątków za pomocą instrukcji try-catch (267)
• Przykład 9.3. Obsługa wyjątków przy obliczaniu NWD (270)
  
  • Jak to działa? (271)
  • Ćwiczenie (272)
    • Ciekawostka - Czy można korzystać z wielu bloków try-catch? (272)
• Podsumowanie rozdziału 9. (273)

Rozdział 10. Orientowanie się na obiekty (275)

• Dlaczego orientować się obiektowo? (276)
  
• Parser łańcuchów znakowych (277)
  
• Obiekty kontra klasy (279)
  
• Inny przykład: klasa Ulamek (279)
  
• Tworzenie i niszczenie obiektów (280)
  
• Dziedziczenie (281)
  
• Tworzenie wspólnych interfejsów (283)
  
• Polimorfizm - prawdziwa niezależność obiektów (285)
  
• Polimorfizm i funkcje wirtualne (287)
  
  • Ciekawostka - Polimorfizm i tradycyjne języki programowania (288)
• A co z wielokrotnym wykorzystywaniem kodu? (289)
  
• Podsumowanie rozdziału 10. (291)

Rozdział 11. Klasa Ulamek (293)

• Punkt - prosta klasa (293)
  
  • Ciekawostka - Dla programistów używających języka C - struktury i klasy (295)
• Teren prywatny - tylko dla swoich, czyli rzecz o ochronie danych (296)
  
• Przykład 11.1. Testowanie klasy Punkt (298)
  
  • Jak to działa? (299)
  • Ćwiczenia (300)
• Wprowadzenie klasy Ulamek (300)
  
• Funkcje inline (303)
  
• Znajdowanie największego wspólnego dzielnika (305)
  
• Znajdowanie najmniejszej wspólnej wielokrotności (307)
  
• Przykład 11.2. Funkcje pomocnicze klasy Ulamek (308)
  
  • Jak to działa? (309)
  • Ćwiczenia (311)
• Przykład 11.3. Testowanie klasy Ulamek (311)
  
  • Jak to działa? (313)
  • Ćwiczenie (314)
    • Ciekawostka - Nowy rodzaj dyrektywy #include? (314)
• Przykład 11.4. Arytmetyka ułamków - dodawanie i mnożenie (315)
  
  • Jak to działa? (317)
  • Ćwiczenia (318)
• Podsumowanie rozdziału 11. (319)

Rozdział 12. Konstruktory - jeśli już budujesz... (321)

• Wprowadzenie do konstruktorów (321)
  
• Definiowanie wielu konstruktorów (przeładowanie) (323)
  
• Konstruktor domyślny... i związane z nim ostrzeżenie (324)
  
  • Ciekawostka - Czy w kwestii domyślnego konstruktora język C++ bawi się z Tobą w kotka i myszkę? (326)
• Przykład 12.1. Konstruktory klasy Punkt (327)
  
  • Jak to działa? (328)
  • Ćwiczenia (328)
• Przykład 12.2. Konstruktory klasy Ulamek (328)
  
  • Jak to działa? (330)
  • Ćwiczenia (331)
• Referencje do zmiennych i argumenty przekazywane przez referencje (&) (331)
  
• Konstruktor kopiujący (333)
  
  • Ciekawostka - Konstruktor kopiujący i referencje (335)
• Przykład 12.3. Konstruktor kopiujący klasy Ulamek (336)
  
  • Jak to działa? (338)
  • Ćwiczenia (338)
• Podsumowanie rozdziału 12. (339)

Rozdział 13. Funkcje operatorowe - zrób to z klasą (341)

• Wprowadzenie do funkcji operatorów działających na klasach (341)
  
• Globalne funkcje operatorowe (344)
  
• Poprawienie wydajności działania kodu za pomocą referencji (346)
  
• Przykład 13.1. Operatory klasy Punkt (349)
  
  • Jak to działa? (350)
  • Ćwiczenia (351)
• Przykład 13.2. Operatory klasy Ulamek (352)
  
  • Jak to działa? (354)
  • Ćwiczenia (355)
• Praca z innymi typami danych (355)
  
• Funkcja operatora przypisania (=) dla klasy Ulamek (356)
  
• Funkcja operatora porównania (==) dla klasy Ulamek (358)
  
  • Ciekawostka - Co z tym typem boolowskim (bool)? (359)
• Funkcja wyświetlająca dla klasy Ulamek (359)
  
• Przykład 13.3. Kompletna klasa Ulamek (361)
  
  • Jak to działa? (364)
  • Ćwiczenia (366)
• Podsumowanie rozdziału 13. (366)

Rozdział 14. Czym jest "new"? Klasa ParserTekstu (369)

• Operator new (370)
  
• Obiekty i operator new (371)
  
• Tworzenie tablic dynamicznych (373)
  
  • Ciekawostka - Radzenie sobie z problemami związanymi z alokacją pamięci (375)
• Przykład 14.1. Dynamiczne przydzielanie pamięci w akcji (376)
  
  • Jak to działa? (376)
  • Ćwiczenie (377)
• Projektowanie parsera (analizatora leksykalnego) (377)
  
• Przykład 14.2. Klasa ParserTekstu (382)
  
  • Jak to działa? (384)
  • Poprawianie kodu (386)
  • Ćwiczenia (387)
• Podsumowanie rozdziału 14. (388)

Rozdział 15. Czym jest "this"? Klasa String (391)

• Wprowadzenie do klasy String (392)
  
• Wprowadzenie do destruktorów klasy (393)
  
• Przykład 15.1. Prosta klasa String (394)
  
  • Jak to działa? (396)
  • Ćwiczenia (398)
• "Głębokie" kopiowanie i konstruktor kopiujący (398)
  
• Słowo kluczowe this (401)
  
• Tworzenie operatora przypisania (402)
  
• Tworzenie funkcji konkatenacji (łączenia) (405)
  
• Przykład 15.2. Kompletna klasa String (407)
  
  • Jak to działa? (409)
  • Ćwiczenia (410)
• Podsumowanie rozdziału 15. (411)

Rozdział 16. Dziedziczenie. Cóż to za spadek? (413)

• Dziedziczenie, czyli przyjemne z pożytecznym (414)
  
  • Ciekawostka - Dlaczego nazwy klas bazowych poprzedzone są słowem "public"? (417)
• Przykład 16.1. Klasa UlamekZmp (418)
  
  • Jak to działa? (421)
  • Ćwiczenia (421)
• Problemy związane z klasą UlamekZmp (422)
  
  • Konstruktory domyślne klas pochodnych (423)
  • Konstruktory kopiujące dla klas pochodnych (424)
  • Funkcja operatora przypisania dla klas pochodnych (424)
  • Dodawanie brakujących konstruktorów (424)
  • Rozwiązywanie konfliktów typów z klasą bazową (425)
• Przykład 16.2. Kompletna klasa UlamekZmp (426)
  
  • Jak to działa? (426)
  • Ćwiczenia (427)
• Przykład 16.3. Klasa UlamekPrawidl (427)
  
  • Jak to działa? (429)
  • Ćwiczenia (431)
• Składniki prywatne (private) i chronione (protected) (432)
  
• Przykład 16.4. Elementy składowe będące obiektami - klasa UlamekJedn (434)
  
  • Jak to działa? (436)
  • Ćwiczenie (438)
• Podsumowanie rozdziału 16. (438)

Rozdział 17. Polimorfizm - niezależność obiektów (441)

• Inna metoda opracowania klasy UlamekZmp (442)
  
• Funkcje wirtualne idą z odsieczą! (444)
  
  • Ciekawostka - Jaka jest cena za stosowanie funkcji wirtualnych? (445)
• Przykład 17.1. Zmieniona klasa UlamekZmp (447)
  
  • Jak to działa? (448)
  • Poprawianie kodu (449)
  • Ćwiczenie (451)
• "Czysta wirtualność" i inne skomplikowane zagadnienia (451)
  
• Klasy abstrakcyjne i interfejsy (453)
  
• Dlaczego obiekt cout nie jest prawdziwie polimorficzny? (454)
  
• Przykład 17.2. Prawdziwy polimorfizm - klasa Drukowalny (456)
  
  • Jak to działa? (458)
  • Ćwiczenie (459)
• Słowo (lub dwa słowa) na zakończenie (460)
  
• Słowo na zakończenie zakończenia (461)
  
• Podsumowanie rozdziału 17. (463)

Dodatek A Operatory oferowane przez język C++ (465)

Dodatek B Wbudowane typy danych należące do języka C++ (469)

Dodatek C Podsumowanie składni wyrażeń w języku C++ (471)

• Stałe dosłowne (471)
  
• Podstawowa składnia wyrażeń (472)
  
• Podstawowa składnia poleceń (473)
  
• Struktury kontrolne (473)
  
• Specjalne polecenia kontrolne (476)
  
• Deklaracje danych (477)
  
• Deklaracje funkcji (477)
  
• Deklaracje klas (478)

Dodatek D Kody znaków ASCII (481)

Dodatek E Często używane funkcje biblioteczne (483)

• Funkcje umożliwiające działania na łańcuchach znakowych (483)
  
• Funkcje do konwersji danych (485)
  
• Funkcje wykonujące operacje na pojedynczych znakach (486)
  
• Funkcje matematyczne (487)
  
• Funkcje związane z wyznaczaniem wartości losowych (488)

Dodatek F Słownik trudnych terminów używanych w tej książce (489)

Skorowidz (501)