O autorze (21)

Wstęp (23)

CZĘŚĆ I. PODSTAWY (27)

Lekcja 1. Zaczynamy (29)

• Krótka historia języka C++ (30)
  
  • Powiązanie z językiem C (30)
  • Zalety języka C++ (30)
  • Ewolucja standardu C++ (31)
  • Kto używa programów utworzonych w C++? (31)
• Tworzenie aplikacji C++ (32)
  
  • Kroki prowadzące do wygenerowania pliku wykonywalnego (32)
  • Analiza błędów i ich usuwanie (33)
  • Zintegrowane środowiska programistyczne (33)
  • Tworzenie pierwszej aplikacji w C++ (34)
  • Kompilacja i uruchomienie pierwszej aplikacji w C++ (35)
  • Błędy kompilacji (37)
• Co nowego w C++11? (37)
• Podsumowanie (38)
• Pytania i odpowiedzi (38)
• Warsztaty (39)

Lekcja 2. Anatomia programu C++ (41)

• Komponenty programu (42)
  
  • Dyrektywa preprocesora #include (42)
  • Część główna programu - funkcja main() (43)
  • Wartość zwrotna (44)
• Koncepcja przestrzeni nazw (45)
• Komentarze w kodzie C++ (47)
• Funkcje w C++ (48)
• Podstawowe wejście za pomocą std::cin i wyjście za pomocą std::cout (51)
• Podsumowanie (53)
• Pytania i odpowiedzi (53)
• Warsztaty (54)

Lekcja 3. Zmienne i stałe (55)

• Czym jest zmienna? (56)
  
  • Ogólne omówienie pamięci i adresowania (56)
  • Deklarowanie zmiennych uzyskujących dostęp i używających pamięci (56)
  • Deklarowanie i inicjalizowanie wielu zmiennych tego samego typu (59)
  • Zrozumienie zakresu zmiennej (59)
  • Zmienne globalne (61)
• Typy zmiennych najczęściej używane w C++ (63)
  
  • Użycie typu bool do przechowywania wartości boolowskich (64)
  • Użycie typu char do przechowywania znaków (65)
  • Koncepcja liczb ze znakiem i bez znaku (65)
  • Liczby całkowite ze znakiem, czyli typy short, int, long i long long (66)
  • Liczby całkowite bez znaku, czyli typy unsigned short, unsigned int, unsigned long i unsigned long long (67)
  • Typy zmiennoprzecinkowe float i double (67)
• Określanie wielkości zmiennej za pomocą sizeof (68)
• Użycie typedef do zastąpienia typu zmiennej (72)
• Czym jest stała? (72)
  
  • Dosłowne stałe (73)
  • Deklarowanie zmiennych jako stałych przy użyciu const (74)
  • Deklarowanie stałych za pomocą constexpr (75)
  • Stałe typu wyliczeniowego (76)
  • Definiowanie stałych za pomocą dyrektywy #define (78)
• Nazwy zmiennych i stałych (79)
• Słowa kluczowe, których nie można używać jako nazw zmiennych lub stałych (80)
• Podsumowanie (80)
• Pytania i odpowiedzi (81)
• Warsztaty (84)

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

• Czym jest tablica? (86)
  
  • Kiedy trzeba użyć tablicy? (86)
  • Deklarowanie i inicjalizacja tablic statycznych (87)
  • Jak w tablicy przechowywane są dane? (88)
  • Uzyskanie dostępu do danych przechowywanych w tablicy (90)
  • Modyfikacja danych przechowywanych w tablicy (91)
• Tablice wielowymiarowe (94)
  
  • Deklarowanie i inicjalizowanie tablic wielowymiarowych (95)
  • Uzyskanie dostępu do elementów tablicy wielowymiarowej (95)
• Tablice dynamiczne (97)
• Ciągi tekstowe w stylu C (99)
• Ciągi tekstowe C++ - użycie klasy std::string (102)
• Podsumowanie (104)
• Pytania i odpowiedzi (105)
• Warsztaty (106)

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

• Polecenia (110)
• Polecenia złożone, czyli bloki (111)
• Użycie operatorów (111)
  
  • Operator przypisania (=) (111)
  • Zrozumienie l-wartości i r-wartości (112)
  • Operatory dodawania (+), odejmowania (-), mnożenia (*), dzielenia (/) i reszty z dzielenia (%) (112)
  • Operatory inkrementacji (++) i dekrementacji (--) (113)
  • Operator postfiksowy czy prefiksowy? (114)
  • Operatory równości (==) i nierówności (!=) (117)
  • Operatory relacji (118)
  • Operatory logiczne NOT, AND, OR i XOR (120)
  • Użycie w C++ operatorów logicznych NOT (!), AND (&&) i OR (||) (122)
  • Bitowe operatory NOT (~), AND (&), OR (|) i XOR (^) (126)
  • Operatory bitowego przesunięcia w prawo (>>) oraz w lewo (<<) (128)
  • Złożone operatory przypisania (130)
  • Użycie operatora sizeof w celu określenia ilości pamięci zajmowanej przez zmienną (132)
  • Pierwszeństwo operatorów (133)
• Podsumowanie (136)
• Pytania i odpowiedzi (136)
• Warsztaty (137)

Lekcja 6. Sterowanie przebiegiem działania programu (139)

• Wykonanie warunkowe za pomocą if-else (140)
  
  • Programowanie warunkowe z użyciem if-else (141)
  • Warunkowe wykonanie wielu poleceń (143)
  • Zagnieżdżone polecenia if (145)
  • Przetwarzanie warunkowe za pomocą switch-case (149)
  • Wykonywanie warunkowe przy użyciu operatora ?: (153)
• Wykonywanie kodu w pętlach (154)
  
  • Bardzo prosta pętla wykonywana przy użyciu polecenia goto (155)
  • Pętla while (157)
  • Pętla do...while (159)
  • Pętla for (161)
• Zmiana zachowania pętli za pomocą poleceń continue i break (165)
  
  • Pętle działające w nieskończoność (165)
  • Kontrolowanie pętli działającej w nieskończoność (166)
• Programowanie zagnieżdżonych pętli (169)
  
  • Użycie zagnieżdżonych pętli do iteracji tablic wielowymiarowych (171)
  • Użycie zagnieżdżonych pętli do obliczenia liczb ciągu Fibonacciego (173)
• Podsumowanie (174)
• Pytania i odpowiedzi (175)
• Warsztaty (176)

Lekcja 7. Funkcje (179)

• Kiedy należy stosować funkcje? (180)
  
  • Czym jest prototyp funkcji? (181)
  • Czym jest definicja funkcji? (182)
  • Czym jest wywołanie funkcji i argumenty? (182)
  • Tworzenie funkcji z wieloma parametrami (183)
  • Tworzenie funkcji bez parametrów i bez wartości zwrotnej (185)
  • Parametry funkcji wraz z wartościami domyślnymi (186)
  • Rekurencja, czyli funkcja wywołująca samą siebie (188)
  • Funkcje z wieloma poleceniami return (190)
• Użycie funkcji do pracy z różnymi formami danych (191)
  
  • Przeciążanie funkcji (192)
  • Przekazanie funkcji tablicy wartości (194)
  • Przekazywanie argumentów przez referencję (195)
• Jak wywołania funkcji są obsługiwane przez mikroprocesor? (197)
  
  • Funkcje typu inline (198)
  • Funkcja lambda (200)
• Podsumowanie (202)
• Pytania i odpowiedzi (203)
• Warsztaty (204)

Lekcja 8. Wskaźniki i referencje (207)

• Czym jest wskaźnik? (208)
  
  • Deklaracja wskaźnika (208)
  • Określenie adresu zmiennej przy użyciu operatora referencji (&) (209)
  • Użycie wskaźników do przechowywania adresów (210)
  • Uzyskanie dostępu do danych przy użyciu operatora dereferencji (*) (213)
  • Ile pamięci zabiera wskaźnik? (216)
• Dynamiczna alokacja pamięci (218)
  
  • Użycie operatorów new i delete w celu dynamicznej alokacji i zwalniania pamięci (218)
  • Efektywne użycie operatorów inkrementacji (++) i dekrementacji (--) na wskaźnikach (222)
  • Użycie słowa kluczowego const ze wskaźnikami (225)
  • Przekazywanie wskaźników funkcjom (227)
  • Podobieństwa pomiędzy tablicami i wskaźnikami (228)
• Najczęstsze błędy programistyczne popełniane podczas używania wskaźników (231)
  
  • Wycieki pamięci (232)
  • Kiedy wskaźnik nie prowadzi do poprawnego adresu w pamięci? (232)
  • Zawieszone wskaźniki (nazywane również zabłąkanymi) (234)
• Najlepsze praktyki podczas pracy ze wskaźnikami (234)
  
  • Sprawdzenie, czy żądanie alokacji zakończyło się powodzeniem (236)
• Czym jest referencja? (240)
  
  • Dlaczego referencje są użyteczne? (241)
  • Użycie słowa kluczowego const w referencjach (243)
  • Przekazywanie funkcji argumentów przez referencję (243)
• Podsumowanie (245)
• Pytania i odpowiedzi (245)
• Warsztaty (247)

CZĘŚĆ II. PODSTAWY PROGRAMOWANIA ZORIENTOWANEGO OBIEKTOWO W C++ (249)

Lekcja 9. Klasy i obiekty (251)

• Koncepcja klas i obiektów (252)
  
  • Deklarowanie klasy (252)
  • Tworzenie obiektu klasy (253)
  • Uzyskanie dostępu do elementów składowych przy użyciu operatora kropki (254)
  • Uzyskanie dostępu do elementów składowych przy użyciu operatora wskaźnika (255)
• Słowa kluczowe public i private (257)
  
  • Abstrakcja danych dzięki słowu kluczowemu private (259)
• Konstruktory (261)
  
  • Deklarowanie i implementowanie konstruktora (261)
  • Kiedy i jak używać konstruktorów? (262)
  • Przeciążanie konstruktorów (264)
  • Klasa bez konstruktora domyślnego (267)
  • Parametry konstruktora wraz z wartościami domyślnymi (269)
  • Konstruktory wraz z listami inicjalizacyjnymi (270)
• Destruktor (272)
  
  • Deklarowanie i implementowanie destruktora (272)
  • Kiedy i jak używać destruktorów? (273)
• Konstruktor kopiujący (276)
  
  • Kopiowanie płytkie i związane z tym problemy (276)
  • Wykonanie głębokiej kopii przy użyciu konstruktora kopiującego (279)
  • Konstruktory przenoszące pomagają w poprawieniu wydajności (284)
• Różne sposoby użycia konstruktorów i destruktora (286)
  
  • Klasa, której nie można kopiować (286)
  • Klasa typu Singleton, która pozwala na istnienie tylko jednego egzemplarza (287)
  • Klasy, których egzemplarze nie mogą być tworzone na stosie (290)
• Wskaźnik this (292)
• Operator sizeof() dla klasy (293)
• Jaka jest różnica pomiędzy strukturą i klasą? (297)
• Deklaracja "przyjaciela" klasy (297)
• Podsumowanie (300)
• Pytania i odpowiedzi (300)
• Warsztaty (302)

Lekcja 10. Dziedziczenie (305)

• Podstawy dziedziczenia (306)
  
  • Dziedziczenie i pochodzenie (306)
  • Stosowana w języku C++ składnia pochodzenia (308)
  • Specyfikator dostępu protected (311)
  • Inicjalizacja klasy bazowej - przekazywanie parametrów klasie bazowej (314)
  • Klasy potomne nadpisują metody klasy bazowej (316)
  • Wywoływanie nadpisanych metod klasy bazowej (319)
  • Wywoływanie metod klasy bazowej z poziomu klas potomnych (319)
  • Klasy potomne ukrywają metody klasy bazowej (321)
  • Kolejność użycia konstruktorów (324)
  • Kolejność użycia destruktorów (324)
• Dziedziczenie prywatne (327)
• Dziedziczenie chronione (330)
• Problem segmentowania (333)
• Dziedziczenie wielokrotne (334)
• Podsumowanie (337)
• Pytania i odpowiedzi (338)
• Warsztaty (339)

Lekcja 11. Polimorfizm (341)

• Podstawy polimorfizmu (342)
  
  • Potrzeba stosowania polimorfizmu (342)
  • Zachowanie polimorficzne implementowane przy użyciu funkcji wirtualnych (344)
  • Konieczność stosowania wirtualnych destruktorów (346)
  • Jak działa funkcja wirtualna? Zrozumienie tabeli funkcji wirtualnych (351)
  • Abstrakcyjne klasy bazowe i funkcje czysto wirtualne (355)
• Użycie dziedziczenia prywatnego do rozwiązania problemu niejednoznaczności semantycznej (358)
• Wirtualne konstruktory kopiujące? (363)
• Podsumowanie (367)
• Pytania i odpowiedzi (367)
• Warsztaty (368)

Lekcja 12. Typy operatorów i ich przeciążanie (371)

• Czym są operatory w C++? (372)
• Operatory jednoargumentowe (373)
  
  • Typy operatorów jednoargumentowych (373)
  • Programowanie jednoargumentowego operatora inkrementacji i dekrementacji (374)
  • Programowanie operatorów konwersji (378)
  • Programowanie operatora dereferencji (*) i operatora wyboru elementu składowego (->) (380)
• Operatory dwuargumentowe (384)
  
  • Typy operatorów dwuargumentowych (385)
  • Programowanie operatorów dodawania (a+b) i odejmowania (a-b) (386)
  • Implementowanie operatorów dodawania/przypisania (+=) i odejmowania/przypisania (-=) (389)
  • Przeciążanie operatorów równości (==) i nierówności (!=) (391)
  • Przeciążanie operatorów <, >, <= i >= (394)
  • Przeciążanie kopiującego operatora przypisania (=) (397)
  • Operatory indeksowania (400)
• Funkcja operator() (404)
  
  • Użycie konstruktora przenoszącego i przenoszącego operatora przypisania w wysokowydajnym programowaniu (406)
• Operatory, których nie można ponownie zdefiniować (413)
• Podsumowanie (414)
• Pytania i odpowiedzi (414)
• Warsztaty (415)

Lekcja 13. Operatory rzutowania (417)

• Kiedy trzeba skorzystać z rzutowania? (418)
• Dlaczego rzutowanie w stylu C nie jest popularne wśród niektórych programistów C++? (419)
• Operatory rzutowania C++ (419)
  
  • Użycie static_cast (420)
  • Użycie dynamic_cast i identyfikacja typu w czasie działania (421)
  • Użycie reinterpret_cast (425)
  • Użycie const_cast (426)
• Problemy z operatorami rzutowania C++ (427)
• Podsumowanie (429)
• Pytania i odpowiedzi (429)
• Warsztaty (430)

Lekcja 14. Wprowadzenie do makr i wzorców (433)

• Preprocesor i kompilator (434)
• Użycie dyrektywy #define do definiowania stałych (434)
  
  • Użycie makr do ochrony przed wielokrotnym dołączaniem (437)
• Użycie dyrektywy #define do definiowania funkcji (438)
  
  • Po co te wszystkie nawiasy? (440)
  • Użycie makra assert do sprawdzania wyrażeń (441)
  • Wady i zalety użycia funkcji makro (443)
• Wprowadzenie do wzorców (444)
  
  • Składnia deklaracji wzorca (445)
  • Różne rodzaje deklaracji wzorca (446)
  • Funkcje wzorca (446)
  • Wzorce i bezpieczeństwo typów (448)
  • Klasy wzorca (449)
  • Ustanawianie i specjalizacja wzorca (450)
  • Deklarowanie wzorców z wieloma parametrami (451)
  • Deklarowanie wzorców z parametrami domyślnymi (452)
  • Przykład wzorca (452)
  • Klasy wzorców i statyczne elementy składowe (454)
  • Użycie static_assert do przeprowadzania operacji sprawdzania w trakcie kompilacji (456)
  • Użycie wzorców w praktycznym programowaniu C++ (457)
• Podsumowanie (458)
• Pytania i odpowiedzi (458)
• Warsztaty (459)

CZĘŚĆ III. POZNAJEMY STANDARDOWĄ BIBLIOTEKĘ WZORCÓW (STL) (461)

Lekcja 15. Wprowadzenie do standardowej biblioteki wzorców (463)

• Kontenery STL (464)
  
  • Kontenery sekwencyjne (464)
  • Kontenery asocjacyjne (465)
  • Wybór odpowiedniego kontenera (466)
  • Adaptery (469)
• Iteratory STL (470)
• Algorytmy STL (471)
• Oddziaływania między kontenerami i algorytmami za pomocą iteratorów (472)
  
  • Użycie słowa kluczowego auto pozwalającego kompilatorowi na definicję typu (474)
• Klasy STL string (475)
• Podsumowanie (475)
• Pytania i odpowiedzi (475)
• Warsztaty (476)

Lekcja 16. Klasa string w STL (479)

• Dlaczego potrzebna jest klasa służąca do manipulowania ciągami tekstowymi? (480)
• Praca z klasą STL string (481)
  
  • Ustanawianie obiektu STL string i tworzenie kopii (482)
  • Uzyskanie dostępu do obiektu string i jego zawartości (484)
  • Łączenie ciągów tekstowych (487)
  • Wyszukiwanie znaku bądź podciągu tekstowego w obiekcie string (488)
  • Skracanie obiektu STL string (490)
  • Uproszczenie deklaracji iteratora przy użyciu słowa kluczowego auto (493)
  • Odwracanie zawartości ciągu tekstowego (493)
  • Konwersja wielkości znaków obiektu string (494)
• Implementacja klasy STL string oparta na wzorcach (496)
• Podsumowanie (496)
• Pytania i odpowiedzi (497)
• Warsztaty (497)

Lekcja 17. Dynamiczne klasy tablic w STL (499)

• Charakterystyka klasy std::vector (500)
• Typowe operacje klasy vector (500)
  
  • Ustanawianie klasy vector (500)
  • Wstawianie elementów na końcu przy użyciu push_back() (503)
• Listy inicjalizacyjne (504)
  
  • Wstawianie elementów w określonym położeniu przy użyciu metody insert() (504)
  • Uzyskanie dostępu do elementów obiektu vector przy użyciu semantyki tablicy (508)
  • Uzyskanie dostępu do elementów obiektu vector przy użyciu semantyki wskaźnika (510)
  • Usuwanie elementów z obiektu vector (511)
• Zrozumienie koncepcji wielkości i pojemności (513)
• Klasa STL deque (515)
• Podsumowanie (518)
• Pytania i odpowiedzi (519)
• Warsztaty (520)

Lekcja 18. Klasy STL list i forward_list (523)

• Charakterystyka klasy std::list (524)
• Podstawowe operacje klasy list (524)
  
  • Ustanawianie obiektu std::list (524)
  • Wstawianie elementów na początku obiektu list (526)
  • Wstawianie elementów w środku obiektu list (529)
  • Usuwanie elementów w obiekcie list (531)
• Odwrócenie i sortowanie elementów w obiekcie list (533)
  
  • Odwracanie elementów (534)
  • Sortowanie elementów (535)
  • Sortowanie i usuwanie elementów listy zawierających obiekty danej klasy (538)
• Podsumowanie (544)
• Pytania i odpowiedzi (545)
• Warsztaty (545)

Lekcja 19. Klasy STL set (547)

• Wprowadzenie do klas STL set (548)
• Podstawowe operacje klas STL set i multiset (549)
  
  • Ustanawianie obiektu std::set (549)
  • Wstawianie elementów do obiektów set lub multiset (552)
  • Wyszukiwanie elementów w obiektach STL set lub multiset (554)
  • Usuwanie elementów z obiektów STL set lub multiset (556)
• Wady i zalety używania obiektów STL set i multiset (562)
• Podsumowanie (566)
• Pytania i odpowiedzi (566)
• Warsztaty (567)

Lekcja 20. Klasy STL map (569)

• Krótkie wprowadzenie do klas STL map (570)
• Podstawowe operacje klas STL map i multimap (571)
  
  • Ustanawianie obiektu std::map lub std::multimap (571)
  • Wstawianie elementów do obiektów STL map lub multimap (573)
  • Wyszukiwanie elementów w obiekcie STL map (577)
  • Wyszukiwanie elementów w obiekcie STL multimap (579)
  • Usuwanie elementów z obiektów STL map lub multimap (580)
• Dostarczanie własnego predykatu sortowania (583)
  
  • Jak działa tabela hash? (588)
  • Używanie tabel hash w C++11: unordered_map i unordered_multimap (588)
• Podsumowanie (593)
• Pytania i odpowiedzi (593)
• Warsztaty (594)

CZĘŚĆ IV. JESZCZE WIĘCEJ STL (597)

Lekcja 21. Zrozumienie obiektów funkcji (599)

• Koncepcja obiektów funkcji i predykatów (600)
• Typowe aplikacje obiektów funkcji (600)
  
  • Funkcje jednoargumentowe (600)
  • Predykat jednoargumentowy (606)
  • Funkcje dwuargumentowe (608)
  • Predykat dwuargumentowy (611)
• Podsumowanie (614)
• Pytania i odpowiedzi (614)
• Warsztaty (615)

Lekcja 22. Wyrażenia lambda w C++11 (617)

• Czym są wyrażenia lambda? (618)
• W jaki sposób zdefiniować wyrażenie lambda? (619)
• Wyrażenie lambda dla funkcji jednoargumentowej (619)
• Wyrażenie lambda dla predykatu jednoargumentowego (621)
• Wyrażenie lambda wraz ze stanem przy użyciu listy przechwytywania [...] (622)
• Ogólna składnia wyrażeń lambda (624)
• Wyrażenie lambda dla funkcji dwuargumentowej (626)
• Wyrażenie lambda dla predykatu dwuargumentowego (628)
• Podsumowanie (631)
• Pytania i odpowiedzi (632)
• Warsztaty (632)

Lekcja 23. Algorytmy STL (635)

• Co to są algorytmy STL? (636)
• Klasyfikacja algorytmów STL (636)
  
  • Algorytmy niezmienne (636)
  • Algorytmy zmienne (638)
• Używanie algorytmów STL (640)
  
  • Znajdowanie elementów o podanej wartości lub warunku (640)
  • Zliczanie elementów o podanej wartości lub warunku (643)
  • Wyszukiwanie elementu lub zakresu w kolekcji (645)
  • Inicjalizacja w kontenerze elementów wraz z określonymi wartościami (648)
  • Użycie std::generate() do inicjalizacji elementów wartościami wygenerowanymi w trakcie działania programu (650)
  • Przetwarzanie elementów w zakresie za pomocą for_each (652)
  • Przeprowadzanie transformacji zakresu za pomocą std::transform (654)
  • Operacje kopiowania i usuwania (657)
  • Zastępowanie wartości oraz zastępowanie elementu na podstawie danego warunku (661)
  • Sortowanie i przeszukiwanie posortowanej kolekcji oraz usuwanie duplikatów (663)
  • Partycjonowanie zakresu (666)
  • Wstawianie elementów do posortowanej kolekcji (669)
• Podsumowanie (672)
• Pytania i odpowiedzi (672)
• Warsztaty (673)

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

• Cechy charakterystyczne zachowania stosów i kolejek (676)
  
  • Stosy (676)
  • Kolejki (676)
• Używanie klasy STL stack (677)
  
  • Ustanawianie obiektu stack (677)
  • Funkcje składowe klasy stack (679)
  • Wstawianie i usuwanie elementów z góry stosu przy użyciu metod push() i pop() (679)
• Używanie klasy STL queue (681)
  
  • Ustanawianie obiektu queue (682)
  • Funkcje składowe klasy queue (683)
  • Wstawianie na końcu i usuwanie na początku kolejki przy użyciu metod push() i pop() (684)
• Używanie klasy STL priority_queue (686)
  
  • Ustanawianie obiektu priority_queue (686)
  • Funkcje składowe klasy priority_queue (688)
  • Wstawianie na końcu i usuwanie na początku kolejki priorytetowej przy użyciu metod push() i pop() (689)
• Podsumowanie (692)
• Pytania i odpowiedzi (692)
• Warsztaty (693)

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

• Klasa bitset (696)
  
  • Ustanowienie klasy std::bitset (696)
• Używanie klasy std::bitset i jej elementów składowych (698)
  
  • Operatory std::bitset (698)
  • Metody składowe klasy std::bitset (699)
• Klasa vector<bool> (702)
  
  • Ustanowienie klasy vector<bool> (702)
  • Używanie klasy vector<bool> (703)
• Podsumowanie (704)
• Pytania i odpowiedzi (705)
• Warsztaty (705)

CZĘŚĆ V. ZAAWANSOWANE KONCEPCJE C++ (707)

Lekcja 26. Sprytne wskaźniki (709)

• Czym są sprytne wskaźniki? (710)
  
  • Na czym polega problem związany z używaniem wskaźników konwencjonalnych? (710)
  • W jaki sposób sprytne wskaźniki mogą pomóc? (711)
• W jaki sposób są implementowane sprytne wskaźniki? (711)
• Typy sprytnych wskaźników (713)
  
  • Kopiowanie głębokie (714)
  • Mechanizm kopiowania przy zapisie (COW) (716)
  • Sprytne wskaźniki zliczania odniesień (716)
  • Sprytne wskaźniki powiązane z licznikiem odniesień (717)
  • Kopiowanie destrukcyjne (718)
  • Używanie klasy std::unique_ptr (720)
• Popularne biblioteki sprytnych wskaźników (722)
• Podsumowanie (723)
• Pytania i odpowiedzi (723)
• Warsztaty (724)

Lekcja 27. Użycie strumieni w operacjach wejścia-wyjścia (727)

• Koncepcja strumieni (728)
• Ważne klasy i obiekty strumieni C++ (729)
• Użycie std::cout do zapisu w konsoli sformatowanych danych (731)
  
  • Użycie std::cout do zmiany formatu wyświetlanych liczb (731)
  • Wyrównanie tekstu i ustawienie szerokości pola przy użyciu std::cout (734)
• Użycie std::cin dla danych wejściowych (735)
  
  • Użycie std::cin w celu umieszczenia danych wejściowych w zmiennych typu POD (735)
  • Użycie std::cin::get w celu umieszczenia danych wejściowych w buforze typu char w stylu C (736)
  • Użycie std::cin w celu umieszczenia danych wejściowych w std::string (738)
• Użycie std::fstream do obsługi pliku (739)
  
  • Otwieranie i zamykanie pliku przy użyciu metod open() i close() (740)
  • Tworzenie i zapisywanie tekstu w pliku przy użyciu metody open() i operatora << (741)
  • Odczyt tekstu z pliku przy użyciu metody open() i operatora >> (742)
  • Zapis i odczyt pliku binarnego (744)
• Użycie std::stringstream do konwersji ciągu tekstowego (746)
• Podsumowanie (748)
• Pytania i odpowiedzi (748)
• Warsztaty (749)
  
  • Quiz (749)
  • Ćwiczenia (749)

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

• Czym jest wyjątek? (752)
• Co powoduje zgłoszenie wyjątku? (753)
• Implementacja bezpieczeństwa wyjątków przy użyciu try i catch (753)
  
  • Użycie catch(...) do obsługi wszystkich wyjątków (753)
  • Przechwytywanie wyjątku określonego typu (755)
  • Użycie throw do zgłoszenia wyjątku określonego typu (757)
• Jak działa obsługa wyjątków? (758)
  
  • Wyjątki klasy std::exception (761)
  • Własna klasa wyjątku wywodząca się z std::exception (762)
• Podsumowanie (765)
• Pytania i odpowiedzi (765)
• Warsztaty (766)

Lekcja 29. Co dalej? (769)

• Czym wyróżniają się obecnie stosowane procesory? (770)
• Jak lepiej używać wielu rdzeni? (771)
  
  • Czym jest wątek? (772)
  • Dlaczego należy tworzyć aplikacje wielowątkowe? (772)
  • Jak wątki wymieniają dane? (773)
  • Użycie muteksu i semaforów do synchronizacji wątków (774)
  • Problemy powodowane przez wielowątkowość (775)
• Tworzenie doskonałego kodu C++ (776)
• Ucz się C++. Nie poprzestań na tym, czego się tu dowiedziałeś! (778)
  
  • Dokumentacja w internecie (778)
  • Społeczności, w których możesz uzyskać porady i pomoc (779)
• Podsumowanie (779)
• Pytania i odpowiedzi (780)
• Warsztaty (780)

DODATKI (781)

Dodatek A. Praca z liczbami: dwójkowo i szesnastkowo (783)

• System liczb dziesiętnych (784)
• System liczb dwójkowych (784)
  
  • Dlaczego w komputerach używany jest system dwójkowy? (785)
  • Czym są bity i bajty? (785)
  • Ile bajtów jest w kilobajcie? (786)
• System liczb szesnastkowych (786)
  
  • Dlaczego potrzebujemy systemu szesnastkowego? (787)
• Konwersja na inną podstawę (787)
  
  • Ogólny proces konwersji (787)
  • Konwersja liczby dziesiętnej na dwójkową (787)
  • Konwersja liczby dziesiętnej na szesnastkową (788)

Dodatek B. Słowa kluczowe C++ (789)

Dodatek C. Kolejność operatorów (791)

Dodatek D. Odpowiedzi (793)

Dodatek E. Kody ASCII (839)

• Tabela ASCII znaków wyświetlanych na ekranie (840)

Skorowidz (845)

• Tytuł: C++. Dla każdego. Wydanie VII
• Autor: Siddhartha Rao
• Tytuł oryginału: Sams Teach Yourself C++ in One Hour a Day (7th Edition)
• Tłumaczenie: Robert Górczyński
• ISBN: 978-83-246-8078-8, 9788324680788
• Data wydania: 2014-01-31
• Format: Ebook
• Identyfikator pozycji: cppit7
• Wydawca: Helion