• Jak nauczyć się języka C++ w 3 tygodnie?
• Jak działają wskaźniki?
• Jak wykorzystać polimorfizm w programowaniu obiektowym?

Pomimo swojego wieku, język C++ wciąż utrzymuje wysoką formę. Przez lata zdobył i ugruntował sobie świetną pozycję na rynku języków programowania. Dzięki temu, nawet dziś w czasach gdzie króluje język Java oraz platforma .NET, wciąż swoich zwolenników. Ba! Istnieją takie gałęzie oprogramowania, w których jest on niezastąpiony. Dlatego jeżeli oczekujesz najwyższej wydajności, operowania blisko sprzętu oraz pełnej kontroli nad sposobem wykonywania programu powinieneś postawić właśnie na C++.

Dzięki książce, którą trzymasz w ręku będzie to stosunkowo proste zadanie. Poświęcając tylko godzinę dziennie zdobędziesz wiedzę, która pozwoli Ci spokojnie rozpocząć przygodę z językiem C++, poznać jego tajniki, zalety oraz wady. Z każdą kolejną godziną będziesz zdobywać coraz to bardziej zaawansowaną i ciekawą wiedzę. Jaki więc zakres obejmuje niniejszy podręcznik? Kompletny, którego opanowanie pozwoli Ci na pisanie programów o różnym stopniu złożoności oraz swobodne poruszanie się w świecie języka C++. Zdobędziesz informacje na temat stałych, zmiennych, tablic, instrukcji warunkowych oraz pętli. Ponadto dowiesz się, jak wykorzystać wskaźniki oraz dyrektywy kompilatora. Natomiast lektura ostatnich rozdziałów książki pozwoli Ci na swobodne poruszanie się w świecie programowania obiektowego, strumieni oraz klas STL. Obiekty, klasy, dziedziczenie czy polimorfizm – te pojęcia nie skryją przed Tobą już żadnej tajemnicy! Kolejne wydanie cenionej książki sprawdzi się w rękach każdego adepta języka C++. Jeżeli chcesz poznać ten język, to nie ma na co czekać. Lepszej okazji nie będzie!

• Historia języka C++
• Konstrukcja programu w języku C++
• Komentowanie kodu
• Zmienne i stałe
• Zastosowanie tablic i ciągów tekstowych
• Formułowanie wyrażeń
• Instrukcje warunkowe i operatory
• Wykorzystanie i tworzenie funkcji
• Zakresy zmiennych
• Sterowanie przebiegiem programu
• Zasada działania wskaźników
• Programowanie obiektowe — klasy, obiekty, dziedziczenie, polimorfizm
• Rzutowanie
• Wykorzystanie strumieni
• Kompilowanie warunkowe, instrukcje kompilatora

Sprawdź czy język C++ spełni Twoje oczekiwania.

Spis treści:

Część I: Podstawy
Lekcja 1. Zaczynamy (31)

• Krótka historia języka C++ (31)
  • Interpretery i kompilatory (33)
  • Zmiana wymagań, zmiana platform (34)
  • Programowanie proceduralne, strukturalne i obiektowe (35)
  • Programowanie zorientowane obiektowo (36)
  • C++ i programowanie zorientowane obiektowo (37)
• Jak ewoluowało C++ (38)
• Czy należy najpierw poznać C? (39)
• Dodatek Microsoft Managed Extensions for C++ (39)
• Standard ANSI (39)
• Przygotowanie do programowania (40)
• Twoje środowisko programowania (41)
• Tworzenie programu (42)
  • Tworzenie pliku obiektowego za pomocą kompilatora (42)
  • Tworzenie pliku wykonywalnego za pomocą linkera (43)
• Cykl tworzenia programu (43)
• HELLO.cpp - Twój pierwszy program w C++ (45)
• Zaczynamy pracę z kompilatorem (47)
  • Budowanie projektu Hello World (48)
• Błędy kompilacji (49)
• Podsumowanie (50)
• Pytania i odpowiedzi (50)
• Warsztaty (51)
  • Quiz (52)
  • Ćwiczenia (52)

Lekcja 2. Anatomia programu C++ (53)

• Prosty program (53)
• Rzut oka na obiekt cout (56)
• Używanie przestrzeni nazw standardowych (58)
• Komentarze (61)
  • Rodzaje komentarzy (61)
  • Używanie komentarzy (62)
  • Jeszcze jedna uwaga na temat komentarzy (63)
• Funkcje (63)
  • Korzystanie z funkcji (65)
  • Metody kontra funkcje (67)
• Podsumowanie (67)
• Pytania i odpowiedzi (67)
• Warsztaty (68)
  • Quiz (68)
  • Ćwiczenia (69)

Lekcja 3. Zmienne i stałe (71)

• Czym jest zmienna? (71)
  • Dane są przechowywane w pamięci (71)
  • Przydzielanie pamięci (72)
  • Rozmiar liczb całkowitych (73)
  • Zapis ze znakiem i bez znaku (74)
  • Podstawowe typy zmiennych (74)
• Definiowanie zmiennej (75)
  • Uwzględnianie wielkości liter (77)
  • Konwencje nazywania zmiennych (77)
  • Słowa kluczowe (78)
• Określenie ilości pamięci używanej przez typ zmiennej (79)
• Tworzenie kilku zmiennych jednocześnie (81)
• Przypisywanie zmiennym wartości (81)
• Tworzenie aliasów za pomocą typedef (83)
• Kiedy używać typu short, a kiedy typu long? (84)
  • Zawinięcie liczby całkowitej bez znaku (85)
  • Zawinięcie liczby całkowitej ze znakiem (86)
• Znaki (87)
  • Znaki i liczby (88)
  • Znaki specjalne (89)
• Stałe (90)
  • Literały (90)
  • Stałe symboliczne (91)
• Stałe wyliczeniowe (92)
• Podsumowanie (95)
• Pytania i odpowiedzi (96)
• Warsztaty (97)
  • Quiz (97)
  • Ćwiczenia (98)

Lekcja 4. Tablice i ciągi tekstowe (99)

• Czym jest tablica? (99)
  • Elementy tablicy (100)
  • Zapisywanie za końcem tablicy (102)
  • Błąd słupka w płocie (104)
  • Inicjalizowanie tablic (105)
  • Deklarowanie tablic (106)
• Tablice wielowymiarowe (107)
  • Deklarowanie tablic wielowymiarowych (108)
  • Inicjalizowanie tablic wielowymiarowych (110)
• Tablice znaków i ciągi tekstowe (113)
• Metody strcpy() oraz strncpy() (115)
• Klasy ciągów tekstowych (117)
• Podsumowanie (120)
• Pytania i odpowiedzi (120)
• Warsztaty (121)
  • Quiz (121)
  • Ćwiczenia (122)

Lekcja 5. Wyrażenia, instrukcje i operatory (123)

• Instrukcje (123)
  • Białe znaki (124)
  • Bloki i instrukcje złożone (124)
• Wyrażenia (125)
• Operatory (126)
  • Operator przypisania (127)
  • Operatory matematyczne (127)
• Łączenie operatora przypisania z operatorem matematycznym (130)
• Inkrementacja i dekrementacja (130)
  • Przedrostki i przyrostki (131)
• Kolejność działań (133)
• Zagnieżdżanie nawiasów (134)
• Prawda i fałsz (135)
  • Operatory relacji (136)
• Instrukcja if (137)
  • Styl wcięć (141)
  • Instrukcja else (141)
  • Zaawansowane instrukcje if (143)
• Użycie nawiasów klamrowych w zagnieżdżonych instrukcjach if (146)
• Operatory logiczne (149)
  • Logiczne I (149)
  • Logiczne LUB (150)
  • Logiczne NIE (150)
• Skrócone obliczanie wyrażeń logicznych (150)
• Kolejność operatorów logicznych (151)
• Kilka słów na temat prawdy i fałszu (152)
• Operator warunkowy (trójelementowy) (152)
• Podsumowanie (154)
• Pytania i odpowiedzi (154)
• Warsztaty (155)
  • Quiz (155)
  • Ćwiczenia (156)

Lekcja 6. Funkcje (159)

• Czym jest funkcja? (159)
• Zwracane wartości, parametry i argumenty (160)
• Deklarowanie i definiowanie funkcji (161)
  • Prototypy funkcji (162)
  • Definiowanie funkcji (164)
• Wykonywanie funkcji (166)
• Zakres zmiennej (166)
  • Zmienne lokalne (166)
  • Zmienne lokalne zdefiniowane w blokach (168)
• Parametry są zmiennymi lokalnymi (170)
  • Zmienne globalne (172)
  • Zmienne globalne: ostrzeżenie (173)
• Rozważania na temat tworzenia instrukcji funkcji (174)
• Kilka słów na temat argumentów funkcji (174)
• Kilka słów na temat zwracanych wartości (175)
• Parametry domyślne (178)
• Przeciążanie funkcji (181)
• Zagadnienia związane z funkcjami (185)
  • Funkcje typu inline (185)
  • Rekurencja (188)
• Jak działają funkcje - rzut oka "pod maskę" (193)
  • Poziomy abstrakcji (193)
• Podsumowanie (198)
• Pytania i odpowiedzi (199)
• Warsztaty (200)
  • Quiz (200)
  • Ćwiczenia (200)

Lekcja 7. Sterowanie przebiegiem działania programu (203)

• Pętle (203)
  • Początki pętli: instrukcja goto (203)
  • Dlaczego nie jest zalecane stosowanie instrukcji goto? (205)
• Pętle while (205)
  • Bardziej skomplikowane instrukcje while (207)
  • Instrukcje continue oraz break (209)
  • Pętla while (true) (212)
• Implementacja pętli do...while (213)
• Używanie pętli do...while (214)
• Pętle for (216)
  • Zaawansowane pętle for (219)
  • Puste pętle for (222)
  • Pętle zagnieżdżone (223)
  • Zakres zmiennych w pętlach for (225)
• Podsumowanie pętli (226)
• Sterowanie przebiegiem działania programu za pomocą instrukcji switch (229)
  
  • Użycie instrukcji switch w menu (232)
• Podsumowanie (236)
• Pytania i odpowiedzi (236)
• Warsztaty (237)
  • Quiz (238)
  • Ćwiczenia (238)

Lekcja 8. Wskaźniki (241)

• Czym jest wskaźnik? (241)
  • Kilka słów na temat pamięci (241)
  • Użycie operatora adresu zmiennej w pamięci (&) (242)
  • Przechowywanie adresu zmiennej we wskaźniku (244)
  • Nazwy wskaźników (244)
  • Pobranie wartości ze zmiennej (245)
  • Dereferencja za pomocą operatora wyłuskania (246)
  • Wskaźniki, adresy i zmienne (247)
  • Operowanie danymi poprzez wskaźniki (248)
  • Sprawdzanie adresu (250)
  • Nazwy wskaźników i tablic (252)
  • Wskaźnik do tablicy kontra tablica wskaźników (254)
• Do czego służą wskaźniki? (255)
• Stos i sterta (255)
  • Alokacja pamięci za pomocą słowa kluczowego new (257)
  • Zwalnianie pamięci: słowo kluczowe delete (258)
• Inne spojrzenie na wycieki pamięci (260)
• Tworzenie obiektów na stercie (261)
• Usuwanie obiektów ze sterty (261)
• Utracone wskaźniki (263)
• Wskaźniki const (267)
• Podsumowanie (268)
• Pytania i odpowiedzi (268)
• Warsztaty (269)
  • Quiz (269)
  • Ćwiczenia (269)

Lekcja 9. Referencje (271)

• Czym jest referencja? (271)
• Użycie operatora adresu (&) z referencją (273)
  • Nie można zmieniać przypisania referencji (275)
• Zerowe wskaźniki i zerowe referencje (276)
• Przekazywanie argumentów funkcji przez referencję (277)
  • Tworzenie funkcji swap() otrzymującej wskaźniki (279)
  • Implementacja funkcji swap() za pomocą referencji (281)
• Zwracanie kilku wartości (283)
  • Zwracanie wartości przez referencję (285)
• Przekazywanie przez referencję zwiększa efektywność działania programu (286)
  • Przekazywanie wskaźnika const (290)
  • Referencje jako metoda alternatywna (293)
• Kiedy używać wskaźników, a kiedy referencji (295)
• Łączenie referencji i wskaźników (296)
• Zwracanie referencji do obiektu, którego nie ma w zakresie (298)
  • Problem związany ze zwracaniem referencji do obiektu na stercie (299)
• Podsumowanie (301)
• Pytania i odpowiedzi (301)
• Warsztaty (302)
  • Quiz (302)
  • Ćwiczenia (302)

Część II: Podstawy programowania zorientowanego obiektowo i C++
Lekcja 10. Klasy i obiekty (307)

• Czy C++ jest zorientowane obiektowo? (307)
• Tworzenie nowych typów (309)
• Wprowadzenie klas i elementów składowych (310)
  • Deklarowanie klasy (311)
  • Kilka słów o konwencji nazw (311)
  • Definiowanie obiektu (313)
  • Klasy a obiekty (313)
• Dostęp do elementów składowych klasy (313)
  • Przypisywać należy obiektom, nie klasom (314)
  • Czego nie zadeklarujesz, tego klasa nie będzie miała (314)
• Dostęp prywatny i publiczny (315)
  • Oznaczanie danych składowych jako prywatnych (317)
• Implementowanie metod klasy (321)
• Konstruktory i destruktory (324)
  • Domyślne konstruktory i destruktory (325)
  • Użycie domyślnego konstruktora (326)
• Funkcje składowe const (329)
• Gdzie umieszczać deklaracje klasy i definicje metod (331)
• Implementacja inline (332)
• Klasy, których danymi składowymi są inne klasy (335)
• Struktury (340)
• Podsumowanie (340)
• Pytania i odpowiedzi (341)
• Warsztaty (343)
  • Quiz (343)
  • Ćwiczenia (343)

Lekcja 11. Dziedziczenie (345)

• Czym jest dziedziczenie? (345)
  • Dziedziczenie i wyprowadzanie (346)
  • Królestwo zwierząt (347)
  • Składnia wyprowadzania (348)
• Prywatne kontra chronione (350)
• Dziedziczenie oraz konstruktory i destruktory (353)
  • Przekazywanie argumentów do konstruktorów bazowych (355)
• Przesłanianie funkcji klasy bazowej (360)
  • Ukrywanie metod klasy bazowej (363)
  • Wywoływanie metod klasy bazowej (365)
• Metody wirtualne (367)
  • Jak działają funkcje wirtualne (372)
  • Próba uzyskania dostępu do metod klasy bazowej (373)
  • Okrajanie (374)
  • Tworzenie destruktorów wirtualnych (377)
  • Wirtualne konstruktory kopiujące (377)
  • Koszt metod wirtualnych (381)
• Dziedziczenie prywatne (381)
  • Używanie dziedziczenia prywatnego (382)
  • Dziedziczenie prywatne kontra agregacja (złożenie) (384)
• Podsumowanie (385)
• Pytania i odpowiedzi (386)
• Warsztaty (387)
  • Quiz (387)
  • Ćwiczenia (388)

Lekcja 12. Polimorfizm (389)

• Problemy z pojedynczym dziedziczeniem (389)
  • Przenoszenie w górę (392)
  • Rzutowanie w dół (393)
  • Połączenie dwóch list (396)
• Dziedziczenie wielokrotne (397)
  • Części obiektu z dziedziczeniem wielokrotnym (401)
  • Konstruktory w obiektach dziedziczonych wielokrotnie (402)
  • Eliminowanie niejednoznaczności (405)
  • Dziedziczenie ze wspólnej klasy bazowej (406)
  • Dziedziczenie wirtualne (410)
  • Problemy z dziedziczeniem wielokrotnym (415)
  • Mixiny i klasy metod (415)
• Abstrakcyjne typy danych (416)
  • Czyste funkcje wirtualne (420)
  • Implementowanie czystych funkcji wirtualnych (422)
  • Złożone hierarchie abstrakcji (426)
  • Które typy są abstrakcyjne? (430)
• Podsumowanie (430)
• Pytania i odpowiedzi (431)
• Warsztaty (432)
  • Quiz (432)
  • Ćwiczenia (433)

Lekcja 13. Typy operatorów i przeciążanie operatorów (435)

• Czym są operatory w C++? (435)
• Operatory jednoargumentowe (436)
  • Typy operatorów jednoargumentowych (437)
  • Programowanie jednoargumentowego operatora inkrementacji i dekrementacji (437)
  • Programowanie operatora dereferencji * i operatora wyboru elementu składowego -> (441)
  • Programowanie operatorów konwersji (444)
• Operatory dwuargumentowe (446)
  • Typy operatorów dwuargumentowych (446)
  • Programowanie operatorów dodawania (a+b) i odejmowania (a-b) (447)
  • Programowanie operatorów dodawania/przypisania i odejmowania/przypisania (450)
  • Przeciążanie operatorów porównywania (452)
  • Przeciążanie operatorów <, >, <= i >= (456)
  • Operatory indeksowania (459)
• Funkcja operator() (462)
• Operatory, których nie można ponownie zdefiniować (463)
• Podsumowanie (464)
• Pytania i odpowiedzi (464)
• Warsztaty (465)
  • Quiz (465)
  • Ćwiczenia (465)

Lekcja 14. Operatory rzutowania (467)

• Co to jest rzutowanie? (467)
• Kiedy zachodzi potrzeba rzutowania? (467)
• Dlaczego rzutowanie w stylu C nie jest popularne wśród niektórych programistów C++? (468)
  
• Operatory rzutowania C++ (469)
  • Użycie static_cast (470)
  • Użycie dynamic_cast i identyfikacja typu w czasie działania (471)
  • Użycie reinterpret_cast (474)
  • Użycie const_cast (475)
• Problemy z operatorami rzutowania C++ (476)
• Podsumowanie (477)
• Pytania i odpowiedzi (477)
• Warsztaty (478)
  • Quiz (478)

Lekcja 15. Wprowadzenie do makr i wzorców (481)

• Preprocesor i kompilator (481)
• Dyrektywa #define preprocesora (482)
• Funkcje makro (482)
  • Po co te wszystkie nawiasy? (484)
  • W jaki sposób makra i słabe bezpieczeństwo typów idą ręka w rękę? (485)
  • Makra a funkcje i wzorce (486)
  • Funkcje inline (486)
• Wprowadzenie do wzorców (488)
  • Składnia deklaracji wzorca (489)
  • Różne rodzaje deklaracji wzorca (490)
  • Klasy wzorca (490)
  • Ustanawianie i specjalizacja wzorca (491)
  • Wzorce i bezpieczeństwo typów (492)
  • Deklarowanie wzorców z wieloma parametrami (492)
  • Deklarowanie wzorców z parametrami domyślnymi (493)
  • Przykład wzorca (493)
  • Użycie wzorców w praktycznym programowaniu C++ (495)
• Podsumowanie (496)
• Pytania i odpowiedzi (496)
• Warsztaty (498)
  • Quiz (498)
  • Ćwiczenia (498)

Część III: Poznajemy standardową bibliotekę wzorców (STL)
Lekcja 16. Wprowadzenie do standardowej biblioteki wzorców (501)

• Kontenery STL (501)
  • Kontenery sekwencyjne (501)
  • Kontenery asocjacyjne (502)
  • Wybór odpowiedniego kontenera (503)
• Iteratory STL (503)
• Algorytmy STL (506)
• Oddziaływania między kontenerami i algorytmami za pomocą iteratorów (507)
  
• Podsumowanie (509)
• Pytania i odpowiedzi (510)
• Warsztaty (510)
  • Quiz (511)

Lekcja 17. Klasa string w STL (513)

• Potrzeba powstania klasy służącej do manipulowania ciągami tekstowymi (513)
• Praca z klasą STL string (515)
  • Ustanawianie obiektu STL string i tworzenie kopii (515)
  • Uzyskanie dostępu do obiektu string i jego zawartości (518)
  • Łączenie ciągów tekstowych (520)
  • Wyszukiwanie znaku bądź podciągu tekstowego w obiekcie string (521)
  • Skracanie obiektu STL string (523)
  • Odwracanie zawartości ciągu tekstowego (525)
  • Konwersja wielkości znaków obiektu string (526)
• Bazująca na wzorcach implementacja klasy STL string (528)
• Podsumowanie (528)
• Pytania i odpowiedzi (529)
• Warsztaty (529)
  • Quiz (529)
  • Ćwiczenia (530)

Lekcja 18. Dynamiczne klasy tablic w STL (531)

• Charakterystyka klasy std::vector (531)
• Typowe operacje klasy vector (532)
  • Ustanawianie klasy vector (532)
  • Wstawianie elementów do obiektu vector (533)
  • Uzyskanie dostępu do elementów obiektu vector (538)
  • Usuwanie elementów z obiektu vector (541)
• Zrozumienie funkcji size() i capacity() (542)
• Klasa STL deque (545)
• Podsumowanie (547)
• Pytania i odpowiedzi (547)
• Warsztaty (548)
  • Quiz (549)
  • Ćwiczenia (549)

Lekcja 19. Klasa STL list (551)

• Charakterystyka klasy std::list (551)
• Podstawowe operacje klasy list (552)
  • Ustanawianie obiektu std::list (552)
  • Wstawianie elementów na początku obiektu list (552)
  • Wstawianie elementów na końcu obiektu list (554)
  • Wstawianie elementów w środku obiektu list (555)
  • Usuwanie elementów w obiekcie list (558)
• Odwrócenie i sortowanie elementów w obiekcie list (560)
  • Odwracanie elementów (561)
  • Sortowanie elementów (562)
• Podsumowanie (573)
• Pytania i odpowiedzi (573)
• Warsztaty (574)
  • Quiz (574)
  • Ćwiczenia (574)

Lekcja 20. Klasy STL set i multiset (575)

• Wprowadzenie (575)
• Podstawowe operacje klas STL set i multiset (576)
  • Ustanawianie obiektu std::set (576)
  • Wstawianie elementów do obiektu set lub multiset (577)
  • Wyszukiwanie elementów w obiekcie STL set lub multiset (579)
  • Usuwanie elementów z obiektu STL set lub multiset (581)
• Wady i zalety używania obiektów STL set i multiset (592)
• Podsumowanie (592)
• Pytania i odpowiedzi (592)
• Warsztaty (593)
  • Quiz (593)
  • Ćwiczenia (594)

Lekcja 21. Klasy STL map i multimap (595)

• Krótkie wprowadzenie (595)
• Podstawowe operacje klas STL map i multimap (596)
  • Ustanawianie obiektu std::map (596)
  • Wstawianie elementów do obiektu STL map lub multimap (597)
  • Wyszukiwanie elementów w obiekcie STL map lub multimap (600)
  • Usuwanie elementów z obiektu STL map lub multimap (602)
• Dostarczanie własnego predykatu sortowania (606)
• Podsumowanie (610)
• Pytania i odpowiedzi (610)
• Warsztaty (611)
  • Quiz (612)
  • Ćwiczenia (612)

Część IV: Jeszcze więcej STL
Lekcja 22. Zrozumienie obiektów funkcji (615)

• Koncepcja obiektów funkcji i predykatów (615)
• Typowe aplikacje obiektów funkcji (616)
  • Funkcje jednoargumentowe (616)
  • Predykat jednoargumentowy (621)
  • Funkcje dwuargumentowe (623)
  • Predykat dwuargumentowy (626)
• Podsumowanie (629)
• Pytania i odpowiedzi (629)
• Warsztaty (630)
  • Quiz (630)
  • Ćwiczenia (630)

Lekcja 23. Algorytmy STL (631)

• Co to są algorytmy STL? (631)
• Klasyfikacja algorytmów STL (631)
  • Algorytmy niezmienne (632)
  • Algorytmy zmienne (633)
• Używanie algorytmów STL (636)
  • Zliczanie i znajdowanie elementów (636)
  • Wyszukiwanie elementu lub zakresu w kolekcji (639)
  • Inicjalizacja elementów w kontenerze wraz z określonymi wartościami (642)
  • Przetwarzanie elementów w zakresie za pomocą for_each (645)
  • Przeprowadzanie transformacji zakresu za pomocą std::transform (647)
  • Operacje kopiowania i usuwania (650)
  • Zastępowanie wartości oraz zastępowanie elementu na podstawie danego warunku (654)
  • Sortowanie i przeszukiwanie posortowanej kolekcji oraz usuwanie duplikatów (656)
  • Partycjonowanie zakresu (659)
  • Wstawianie elementów do posortowanej kolekcji (661)
• Podsumowanie (664)
• Pytania i odpowiedzi (664)
• Warsztaty (665)
  • Quiz (665)
  • Ćwiczenia (666)

Lekcja 24. Kontenery adaptacyjne: stack i queue (667)

• Cechy charakterystyczne zachowania stosów i kolejek (667)
  • Stosy (667)
  • Kolejki (668)
• Używanie klasy STL stack (668)
  • Ustanawianie obiektu stack (669)
  • Funkcje składowe klasy stack (670)
• Używanie klasy STL queue (672)
  • Ustanawianie obiektu queue (673)
  • Funkcje składowe klasy queue (674)
• Używanie klasy STL priority_queue (676)
  • Ustanawianie obiektu priority_queue (677)
  • Funkcje składowe klasy priority_queue (678)
• Podsumowanie (682)
• Pytania i odpowiedzi (682)
• Warsztaty (682)
  • Quiz (682)
  • Ćwiczenia (683)

Lekcja 25. Praca z opcjami bitowymi za pomocą STL (685)

• Klasa bitset (685)
  • Ustanowienie klasy std::bitset (685)
• Używanie klasy std::bitset i jej elementów składowych (687)
  • Operatory std::bitset (687)
  • Metody składowe klasy std::bitset (687)
• Klasa vector (691)
  • Ustanowienie klasy vector (691)
  • Używanie klasy vector (692)
• Podsumowanie (693)
• Pytania i odpowiedzi (694)
• Warsztaty (694)
  • Quiz (695)
  • Ćwiczenia (695)

Część V: Zaawansowane koncepcje C++
Lekcja 26. Sprytne wskaźniki (699)

• Czym są sprytne wskaźniki? (699)
  • Na czym polega problem związany z używaniem wskaźników konwencjonalnych? (700)
  • W jaki sposób sprytne wskaźniki mogą pomóc? (701)
• W jaki sposób są implementowane sprytne wskaźniki? (701)
• Typy sprytnych wskaźników (703)
  • Kopiowanie głębokie (704)
  • Mechanizm kopiowania przy zapisie (COW) (706)
  • Sprytne wskaźniki zliczania odniesień (706)
  • Sprytne wskaźniki powiązane z licznikiem odniesień (707)
  • Kopiowanie destrukcyjne (708)
• Używanie klasy std::auto_ptr (710)
• Popularne biblioteki sprytnych wskaźników (712)
• Podsumowanie (713)
• Pytania i odpowiedzi (713)
• Warsztaty (714)
  • Quiz (714)
  • Ćwiczenia (715)

Lekcja 27. Strumienie (717)

• Przegląd strumieni (717)
  • Hermetyzacja przepływu danych (718)
  • Buforowanie (719)
• Strumienie i bufory (721)
• Standardowe obiekty wejścia-wyjścia (722)
• Przekierowywanie standardowych strumieni (722)
• Wejście z użyciem cin (723)
  • Wejściowe ciągi tekstowe (725)
  • Problemy z ciągami tekstowymi (725)
  • Wartość zwracana przez cin (728)
• Inne funkcje składowe w dyspozycji cin (729)
  • Wprowadzanie pojedynczych znaków (729)
  • Odczytywanie ciągów tekstowych z wejścia standardowego (732)
  • Użycie cin.ignore() (735)
  • Funkcje peek() oraz putback() (737)
• Wyjście poprzez cout (738)
  • Zrzucanie zawartości bufora (739)
  • Funkcje obsługujące wyjście (739)
  • Manipulatory, znaczniki oraz instrukcje formatowania (741)
• Strumienie kontra funkcja printf() (747)
• Wejście i wyjście z użyciem plików (751)
  • ofstream (751)
  • Stany strumieni (751)
  • Otwieranie plików dla wejścia i wyjścia (751)
  • Zmiana domyślnego zachowania obiektu ofstream w trakcie otwierania pliku (753)
• Pliki binarne a pliki tekstowe (756)
• Przetwarzanie linii polecenia (759)
• Podsumowanie (763)
• Pytania i odpowiedzi (763)
• Warsztaty (764)
  • Quiz (765)
  • Ćwiczenia (765)

Lekcja 28. Obsługa wyjątków (767)

• Pluskwy, błędy, pomyłki i "psujący się" kod (767)
  • Sytuacje wyjątkowe (768)
• Wyjątki (770)
  • Jak używane są wyjątki (771)
  • Zgłaszanie własnych wyjątków (775)
  • Tworzenie klasy wyjątku (777)
• Umiejscowienie bloków try oraz bloków catch (781)
• Sposób działania przechwytywania wyjątków (781)
  • Wychwytywanie więcej niż jednego rodzaju wyjątków (782)
  • Hierarchie wyjątków (785)
• Dane w wyjątkach oraz nazwane obiekty wyjątków (789)
• Wyjątki i wzorce (796)
• Wyjątki bez błędów (799)
• Błędy i usuwanie błędów (800)
  • Punkty wstrzymania (801)
  • Śledzenie wartości zmiennych (801)
  • Sprawdzanie pamięci (802)
  • Asembler (802)
• Podsumowanie (802)
• Pytania i odpowiedzi (803)
• Warsztaty (804)
  • Quiz (804)
  • Ćwiczenia (805)

Lekcja 29. Więcej informacji na temat preprocesora (807)

• Preprocesor i kompilator (807)
• Użycie dyrektywy #define (808)
  • Użycie #define dla stałych (808)
  • Użycie #define do testowania (809)
  • Dyrektywa #else preprocesora (810)
• Dołączanie i wartowniki dołączania (811)
• Manipulacje ciągami tekstowymi (813)
  • Zamiana na ciąg tekstowy (813)
  • Konkatenacja (813)
• Makra predefiniowane (814)
• Makro assert() (814)
  • Debuggowanie za pomocą makra assert() (816)
  • Makro assert() a wyjątki (817)
  • Efekty uboczne (817)
  • Niezmienniki klas (818)
  • Wyświetlanie wartości tymczasowych (824)
• Operacje na bitach (825)
  • Operator AND (826)
  • Operator OR (826)
  • Operator wyłączający OR (827)
  • Operator negacji (827)
  • Ustawianie bitów (827)
  • Zerowanie bitów (828)
  • Zmiana stanu bitów na przeciwny (828)
  • Pola bitowe (829)
• Styl programowania (832)
  • Wcięcia (833)
  • Nawiasy klamrowe (833)
  • Długość linii oraz długość funkcji (833)
  • Instrukcje switch (834)
  • Tekst programu (834)
  • Nazwy identyfikatorów (835)
  • Pisownia nazw i zastosowanie w nich wielkich liter (836)
  • Komentarze (836)
  • Konfiguracja dostępu (837)
  • Definicje klas (838)
  • Dołączanie plików (838)
  • Używanie makra assert() (838)
  • Używanie modyfikatora const (838)
• Następne kroki w programowaniu C++ (839)
  • Gdzie uzyskać pomoc i poradę (839)
  • Tematy powiązane z C++: rozszerzenie Managed C++, C# oraz platforma .NET firmy Microsoft (840)
• Podsumowanie (841)
• Pytania i odpowiedzi (841)
• Warsztaty (843)
  • Quiz (843)
  • Ćwiczenia (843)

Dodatki
Dodatek A: Praca z liczbami: dwójkowo i szesnastkowo (847)

• Inne podstawy (848)
• Konwersja na inną podstawę (849)
  • Dwójkowo (851)
  • Dlaczego podstawa 2? (852)
  • Bity, bajty, nible (852)
  • Co to jest KB? (853)
  • Liczby dwójkowe (853)
• Szesnastkowo (853)

Dodatek B: Słowa kluczowe C++ (859)
Dodatek C: Kolejność operatorów (861)
Dodatek D: Odpowiedzi (863)