JĘZYK C++ KOMPENDIUM WIEDZY WYD. IV

SPIS TREŚCI

Przedmowa (23)

Przedmowa do wydania trzeciego (27)

Przedmowa do wydania drugiego (29)

Przedmowa do wydania pierwszego (31)

CZĘŚĆ I. WPROWADZENIE (33)

Rozdział 1. Uwagi do czytelnika (35)

• 1.1. Struktura książki (35)
  • 1.1.1. Wprowadzenie (36)
  • 1.1.2. Podstawowe narzędzia (36)
  • 1.1.3. Techniki abstrakcji (37)
  • 1.1.4. Biblioteka standardowa (39)
  • 1.1.5. Przykłady i odwołania (40)
• 1.2. Projekt języka C++ (41)
  • 1.2.1. Styl programowania (43)
  • 1.2.2. Kontrola typów (46)
  • 1.2.3. Zgodność z językiem C (47)
  • 1.2.4. Język, biblioteki i systemy (48)
• 1.3. Nauka języka C++ (50)
  • 1.3.1. Programowanie w języku C++ (52)
  • 1.3.2. Rady dla programistów C++ (53)
  • 1.3.3. Rady dla programistów C (53)
  • 1.3.4. Rady dla programistów języka Java (54)
• 1.4. Historia (55)
  • 1.4.1. Oś czasu (56)
  • 1.4.2. Pierwsze lata (57)
  • 1.4.3. Standard z 1998 r. (59)
  • 1.4.4. Standard z 2011 r. (62)
  • 1.4.5. Do czego jest używany język C++ (65)
• 1.5. Rady (67)
• 1.6. Literatura (68)

Rozdział 2. Kurs języka C++. Podstawy (73)

• 2.1. Wprowadzenie (73)
• 2.2. Podstawy (74)
  • 2.2.1. Witaj, świecie! (75)
  • 2.2.2. Typy, zmienne i arytmetyka (76)
  • 2.2.3. Stałe (78)
  • 2.2.4. Testy i pętle (79)
  • 2.2.5. Wskaźniki, tablice i pętle (80)
• 2.3. Typy zdefiniowane przez użytkownika (82)
  • 2.3.1. Struktury (83)
  • 2.3.2. Klasy (84)
  • 2.3.3. Wyliczenia (86)
• 2.4. Modułowość (87)
  • 2.4.1. Osobna kompilacja (88)
  • 2.4.2. Przestrzenie nazw (89)
  • 2.4.3. Obsługa błędów (90)
• 2.5. Posłowie (93)
• 2.6. Rady (93)

Rozdział 3. Kurs języka C++. Techniki abstrakcji (95)

• 3.1. Wprowadzenie (95)
• 3.2. Klasy (96)
  • 3.2.1. Typy konkretne (96)
  • 3.2.2. Typy abstrakcyjne (101)
  • 3.2.3. Funkcje wirtualne (103)
  • 3.2.4. Hierarchie klas (104)
• 3.3. Kopiowanie i przenoszenie (108)
  • 3.3.1. Kopiowanie kontenerów (108)
  • 3.3.2. Przenoszenie kontenerów (110)
  • 3.3.3. Zarządzanie zasobami (112)
  • 3.3.4. Tłumienie operacji (113)
• 3.4. Szablony (113)
  • 3.4.1. Typy parametryzowane (114)
  • 3.4.2. Szablony funkcji (115)
  • 3.4.3. Obiekty funkcyjne (116)
  • 3.4.4. Zmienne szablony (118)
  • 3.4.5. Aliasy (119)
• 3.5. Rady (120)

Rozdział 4. Kurs języka C++. Kontenery i algorytmy (121)

• 4.1. Biblioteki (121)
  • 4.1.1. Przegląd biblioteki standardowej (122)
  • 4.1.2. Nagłówki i przestrzeń nazw biblioteki standardowej (123)
• 4.2. Łańcuchy (124)
• 4.3. Strumienie wejścia i wyjścia (126)
  • 4.3.1. Wyjście (126)
  • 4.3.2. Wejście (127)
  • 4.3.3. Wejście i wyjście typów zdefiniowanych przez użytkownika (128)
• 4.4. Kontenery (129)
  • 4.4.1. vector (130)
  • 4.4.2. list (133)
  • 4.4.3. map (134)
  • 4.4.4. unordered_map (135)
  • 4.4.5. Przegląd kontenerów (135)
• 4.5. Algorytmy (137)
  • 4.5.1. Używanie iteratorów (138)
  • 4.5.2. Typy iteratorów (140)
  • 4.5.3. Iteratory strumieni (140)
  • 4.5.4. Predykaty (142)
  • 4.5.5. Przegląd algorytmów (143)
  • 4.5.6. Algorytmy kontenerowe (143)
• 4.6. Rady (144)

Rozdział 5. Kurs języka C++. Współbieżność i narzędzia (145)

• 5.1. Wprowadzenie (145)
• 5.2. Zarządzanie zasobami (146)
  • 5.2.1. unique_ptr i shared_ptr (146)
• 5.3. Współbieżność (148)
  • 5.3.1. Zadania i wątki (149)
  • 5.3.2. Przekazywanie argumentów (150)
  • 5.3.3. Zwracanie wyników (150)
  • 5.3.4. Wspólne używanie danych (151)
  • 5.3.5. Komunikacja między zadaniami (154)
• 5.4. Drobne, ale przydatne narzędzia (157)
  • 5.4.1. Czas (157)
  • 5.4.2. Funkcje typowe (158)
  • 5.4.3. pair i tuple (160)
• 5.5. Wyrażenia regularne (161)
• 5.6. Matematyka (162)
  • 5.6.1. Funkcje i algorytmy matematyczne (162)
  • 5.6.2. Liczby zespolone (163)
  • 5.6.3. Liczby losowe (163)
  • 5.6.4. Arytmetyka wektorów (165)
  • 5.6.5. Limity liczbowe (165)
• 5.7. Rady (166)

CZĘŚĆ II. PODSTAWOWE NARZĘDZIA (167)

Rozdział 6. Typy i deklaracje (169)

• 6.1. Standard ISO języka C++ (169)
  • 6.1.1. Implementacje (171)
  • 6.1.2. Podstawowy źródłowy zestaw znaków (171)
• 6.2. Typy (172)
  • 6.2.1. Typy podstawowe (172)
  • 6.2.2. Typ logiczny (173)
  • 6.2.3. Typy znakowe (174)
  • 6.2.4. Typy całkowitoliczbowe (179)
  • 6.2.5. Typy zmiennoprzecinkowe (181)
  • 6.2.6. Przedrostki i przyrostki (182)
  • 6.2.7. void (183)
  • 6.2.8. Rozmiary (183)
  • 6.2.9. Wyrównanie (185)
• 6.3. Deklaracje (186)
  • 6.3.1. Struktura deklaracji (188)
  • 6.3.2. Deklarowanie po kilka nazw (189)
  • 6.3.3. Nazwy (189)
  • 6.3.4. Zakres dostępności (191)
  • 6.3.5. Inicjacja (194)
  • 6.3.6. Dedukowanie typu: auto i decltype() (197)
• 6.4. Obiekty i wartości (200)
  • 6.4.1. Wartości lewo- i prawostronne (200)
  • 6.4.2. Cykl istnienia obiektów (201)
• 6.5. Aliasy typów (202)
• 6.6. Rady (203)

Rozdział 7. Wskaźniki, tablice i referencje (205)

• 7.1. Wprowadzenie (205)
• 7.2. Wskaźniki (205)
  • 7.2.1. void* (206)
  • 7.2.2. nullptr (207)
• 7.3. Tablice (208)
  • 7.3.1. Inicjatory tablic (209)
  • 7.3.2. Literały łańcuchowe (210)
• 7.4. Wskaźniki do tablic (213)
  • 7.4.1. Przeglądanie tablic (214)
  • 7.4.2. Tablice wielowymiarowe (217)
  • 7.4.3. Przekazywanie tablic (217)
• 7.5. Wskaźniki i const (220)
• 7.6. Wskaźniki i własność (221)
• 7.7. Referencje (222)
  • 7.7.1. Referencje lewostronne (224)
  • 7.7.2. Referencje prawostronne (227)
  • 7.7.3. Referencje do referencji (229)
  • 7.7.4. Wskaźniki i referencje (230)
• 7.8. Rady (232)

Rozdział 8. Struktury, unie i wyliczenia (233)

• 8.1. Wprowadzenie (233)
• 8.2. Struktury (234)
  • 8.2.1. Układ struktur (235)
  • 8.2.2. Nazwy struktur (236)
  • 8.2.3. Struktury a klasy (237)
  • 8.2.4. Struktury a tablice (239)
  • 8.2.5. Ekwiwalencja typów (241)
  • 8.2.6. Stare zwykłe dane (241)
  • 8.2.7. Pola (244)
• 8.3. Unie (244)
  • 8.3.1. Unie a klasy (246)
  • 8.3.2. Anonimowe unie (247)
• 8.4. Wyliczenia (249)
  • 8.4.1. Klasy wyliczeniowe (250)
  • 8.4.2. Zwykłe wyliczenia (253)
  • 8.4.3. Wyliczenia anonimowe (254)
• 8.5. Rady (255)

Rozdział 9. Instrukcje (257)

• 9.1. Wprowadzenie (257)
• 9.2. Zestawienie instrukcji (258)
• 9.3. Deklaracje jako instrukcje (259)
• 9.4. Instrukcje wyboru (260)
  • 9.4.1. Instrukcje if (260)
  • 9.4.2. Instrukcje switch (261)
  • 9.4.3. Deklaracje w warunkach (264)
• 9.5. Instrukcje iteracyjne (264)
  • 9.5.1. Zakresowe instrukcje for (265)
  • 9.5.2. Instrukcje for (266)
  • 9.5.3. Instrukcje while (267)
  • 9.5.4. Instrukcje do (267)
  • 9.5.5. Kończenie pętli (268)
• 9.6. Instrukcje goto (269)
• 9.7. Komentarze i wcięcia (269)
• 9.8. Rady (271)

Rozdział 10. Wyrażenia (273)

• 10.1. Wprowadzenie (273)
• 10.2. Kalkulator (273)
  • 10.2.1. Parser (274)
  • 10.2.2. Wejście (278)
  • 10.2.3. Wejście niskopoziomowe (282)
  • 10.2.4. Obsługa błędów (283)
  • 10.2.5. Sterownik (284)
  • 10.2.6. Nagłówki (284)
  • 10.2.7. Argumenty wiersza poleceń (285)
  • 10.2.8. Uwaga na temat stylu (286)
• 10.3. Zestawienie operatorów (287)
  • 10.3.1. Wyniki (291)
  • 10.3.2. Kolejność wykonywania działań (292)
  • 10.3.3. Priorytety operatorów (292)
  • 10.3.4. Obiekty tymczasowe (293)
• 10.4. Wyrażenia stałe (295)
  • 10.4.1. Stałe symboliczne (297)
  • 10.4.2. const w wyrażeniach stałych (297)
  • 10.4.3. Typy literałowe (297)
  • 10.4.4. Argumenty referencyjne (298)
  • 10.4.5. Wyrażenia stałe adresowe (299)
• 10.5. Niejawna konwersja typów (299)
  • 10.5.1. Promocje (300)
  • 10.5.2. Konwersje (300)
  • 10.5.3. Typowe konwersje arytmetyczne (303)
• 10.6. Rady (304)

Rozdział 11. Operacje wyboru (305)

• 11.1. Różne operatory (305)
  • 11.1.1. Operatory logiczne (305)
  • 11.1.2. Bitowe operatory logiczne (306)
  • 11.1.3. Wyrażenia warunkowe (307)
  • 11.1.4. Inkrementacja i dekrementacja (307)
• 11.2. Pamięć wolna (309)
  • 11.2.1. Zarządzanie pamięcią (311)
  • 11.2.2. Tablice (313)
  • 11.2.3. Sprawdzanie dostępności miejsca w pamięci (314)
  • 11.2.4. Przeciążanie operatora new (315)
• 11.3. Listy (318)
  • 11.3.1. Model implementacji (318)
  • 11.3.2. Listy kwalifikowane (319)
  • 11.3.3. Listy niekwalifikowane (320)
• 11.4. Wyrażenia lambda (322)
  • 11.4.1. Model implementacji (322)
  • 11.4.2. Alternatywy dla lambd (323)
  • 11.4.3. Lista zmiennych (325)
  • 11.4.4. Wywoływanie i zwracanie wartości (329)
  • 11.4.5. Typ lambdy (329)
• 11.5. Jawna konwersja typów (330)
  • 11.5.1. Konstrukcja (331)
  • 11.5.2. Rzutowania nazwane (333)
  • 11.5.3. Rzutowanie w stylu języka C (334)
  • 11.5.4. Rzutowanie w stylu funkcyjnym (334)
• 11.6. Rady (335)

Rozdział 12. Funkcje (337)

• 12.1. Deklarowanie funkcji (337)
  • 12.1.1. Dlaczego funkcje (338)
  • 12.1.2. Składniki deklaracji funkcji (338)
  • 12.1.3. Definiowanie funkcji (339)
  • 12.1.4. Zwracanie wartości (340)
  • 12.1.5. Funkcje inline (342)
  • 12.1.6. Funkcje constexpr (343)
  • 12.1.7. Funkcje [[noreturn]] (346)
  • 12.1.8. Zmienne lokalne (346)
• 12.2. Przekazywanie argumentów (347)
  • 12.2.1. Argumenty referencyjne (348)
  • 12.2.2. Argumenty tablicowe (350)
  • 12.2.3. Argumenty listowe (351)
  • 12.2.4. Nieokreślona liczba argumentów (353)
  • 12.2.5. Argumenty domyślne (356)
• 12.3. Przeciążanie funkcji (358)
  • 12.3.1. Automatyczne wybieranie przeciążonych funkcji (358)
  • 12.3.2. Przeciążanie a typ zwrotny (360)
  • 12.3.3. Przeciążanie a zakres (360)
  • 12.3.4. Wybieranie przeciążonych funkcji z wieloma argumentami (361)
  • 12.3.5. Ręczne wybieranie przeciążonej funkcji (362)
• 12.4. Warunki wstępne i końcowe (362)
• 12.5. Wskaźnik do funkcji (364)
• 12.6. Makra (368)
  • 12.6.1. Kompilacja warunkowa (370)
  • 12.6.2. Makra predefiniowane (371)
  • 12.6.3. Pragmy (372)
• 12.7. Rady (372)

Rozdział 13. Obsługa wyjątków (373)

• 13.1. Obsługa błędów (373)
  • 13.1.1. Wyjątki (374)
  • 13.1.2. Tradycyjna obsługa błędów (376)
  • 13.1.3. Niedbała obsługa błędów (377)
  • 13.1.4. Alternatywne spojrzenie na wyjątki (378)
  • 13.1.5. Kiedy nie można używać wyjątków (379)
  • 13.1.6. Hierarchiczna obsługa błędów (380)
  • 13.1.7. Wyjątki a wydajność (381)
• 13.2. Gwarancje wyjątków (383)
• 13.3. Zarządzanie zasobami (385)
  • 13.3.1. Finalizacja (388)
• 13.4. Egzekwowanie przestrzegania niezmienników (389)
• 13.5. Zgłaszanie i przechwytywanie wyjątków (394)
  • 13.5.1. Zgłaszanie wyjątków (394)
  • 13.5.2. Przechwytywanie wyjątków (397)
  • 13.5.3. Wyjątki a wątki (404)
• 13.6. Implementacja wektora (405)
  • 13.6.1. Prosty wektor (405)
  • 13.6.2. Jawna reprezentacja pamięci (409)
  • 13.6.3. Przypisywanie (411)
  • 13.6.4. Zmienianie rozmiaru (413)
• 13.7. Rady (416)

Rozdział 14. Przestrzenie nazw (419)

• 14.1. Kwestie dotyczące kompozycji (419)
• 14.2. Przestrzenie nazw (420)
  • 14.2.1. Bezpośrednia kwalifikacja (422)
  • 14.2.2. Deklaracje using (423)
  • 14.2.3. Dyrektywy using (424)
  • 14.2.4. Wyszukiwanie wg argumentów (425)
  • 14.2.5. Przestrzenie nazw są otwarte (427)
• 14.3. Modularyzacja i interfejsy (428)
  • 14.3.1. Przestrzenie nazw i moduły (430)
  • 14.3.2. Implementacje (431)
  • 14.3.3. Interfejsy i implementacje (433)
• 14.4. Składanie przy użyciu przestrzeni nazw (435)
  • 14.4.1. Wygoda a bezpieczeństwo (435)
  • 14.4.2. Aliasy przestrzeni nazw (436)
  • 14.4.3. Składanie przestrzeni nazw (436)
  • 14.4.4. Składanie i wybieranie (438)
  • 14.4.5. Przestrzenie nazw a przeciążanie (439)
  • 14.4.6. Wersjonowanie (441)
  • 14.4.7. Zagnieżdżanie przestrzeni nazw (443)
  • 14.4.8. Anonimowe przestrzenie nazw (444)
  • 14.4.9. Nagłówki języka C (444)
• 14.5. Rady (445)

Rozdział 15. Pliki źródłowe i programy (447)

• 15.1. Rozdzielna kompilacja (447)
• 15.2. Konsolidacja (448)
  • 15.2.1. Nazwy lokalne w plikach (451)
  • 15.2.2. Pliki nagłówkowe (451)
  • 15.2.3. Reguła jednej definicji (453)
  • 15.2.4. Nagłówki z biblioteki standardowej (455)
  • 15.2.5. Konsolidacja z kodem w innym języku (456)
  • 15.2.6. Konsolidacja a wskaźniki do funkcji (458)
• 15.3. Używanie plików nagłówkowych (459)
  • 15.3.1. Organizacja z jednym nagłówkiem (459)
  • 15.3.2. Organizacja z wieloma nagłówkami (463)
  • 15.3.3. Strażnicy dołączania (467)
• 15.4. Programy (468)
  • 15.4.1. Inicjacja zmiennych nielokalnych (469)
  • 15.4.2. Inicjacja i współbieżność (470)
  • 15.4.3. Zamykanie programu (470)
• 15.5. Rady (472)

CZĘŚĆ III. TECHNIKI ABSTRAKCJI (473)

Rozdział 16. Klasy (475)

• 16.1. Wprowadzenie (475)
• 16.2. Podstawowe wiadomości o klasach (476)
  • 16.2.1. Funkcje składowe (477)
  • 16.2.2. Kopiowanie domyślne (478)
  • 16.2.3. Kontrola dostępu (479)
  • 16.2.4. Klasy i struktury (480)
  • 16.2.5. Konstruktory (481)
  • 16.2.6. Konstruktory explicit (483)
  • 16.2.7. Inicjatory wewnątrzklasowe (485)
  • 16.2.8. Wewnątrzklasowe definicje funkcji (486)
  • 16.2.9. Zmienność (487)
  • 16.2.10. Słowo kluczowe this (490)
  • 16.2.11. Dostęp do składowych (491)
  • 16.2.12. Składowe statyczne (492)
  • 16.2.13. Typy składowe (494)
• 16.3. Klasy konkretne (495)
  • 16.3.1. Funkcje składowe (498)
  • 16.3.2. Funkcje pomocnicze (500)
  • 16.3.3. Przeciążanie operatorów (502)
  • 16.3.4. Znaczenie klas konkretnych (503)
• 16.4. Rady (504)

Rozdział 17. Tworzenie, kasowanie, kopiowanie i przenoszenie (505)

• 17.1. Wprowadzenie (505)
• 17.2. Konstruktory i destruktory (507)
  • 17.2.1. Konstruktory i niezmienniki (508)
  • 17.2.2. Destruktory i zasoby (509)
  • 17.2.3. Destruktory klas bazowych i składowych klas (510)
  • 17.2.4. Wywoływanie konstruktorów i destruktorów (511)
  • 17.2.5. Destruktory wirtualne (512)
• 17.3. Inicjacja obiektów klas (513)
  • 17.3.1. Inicjacja bez konstruktorów (513)
  • 17.3.2. Inicjacja przy użyciu konstruktorów (515)
  • 17.3.3. Konstruktory domyślne (517)
  • 17.3.4. Konstruktory z listą inicjacyjną (519)
• 17.4. Inicjacja składowych i bazy (524)
  • 17.4.1. Inicjacja składowych (524)
  • 17.4.2. Inicjatory bazy (525)
  • 17.4.3. Delegowanie konstruktorów (526)
  • 17.4.4. Inicjatory wewnątrzklasowe (527)
  • 17.4.5. Inicjacja składowych statycznych (529)
• 17.5. Kopiowanie i przenoszenie (530)
  • 17.5.1. Kopiowanie (530)
  • 17.5.2. Przenoszenie (537)
• 17.6. Generowanie domyślnych operacji (541)
  • 17.6.1. Jawne operacje domyślne (541)
  • 17.6.2. Operacje domyślne (542)
  • 17.6.3. Używanie operacji domyślnych (543)
  • 17.6.4. Usuwanie funkcji (547)
• 17.7. Rady (548)

Rozdział 18. Przeciążanie operatorów (551)

• 18.1. Wprowadzenie (551)
• 18.2. Funkcje operatorowe (553)
  • 18.2.1. Operatory dwu- i jednoargumentowe (554)
  • 18.2.2. Predefiniowane znaczenie operatorów (555)
  • 18.2.3. Operatory i typy zdefiniowane przez użytkownika (555)
  • 18.2.4. Przekazywanie obiektów (556)
  • 18.2.5. Operatory w przestrzeniach nazw (557)
• 18.3. Typ reprezentujący liczby zespolone (559)
  • 18.3.1. Operatory składowe i zewnętrzne (559)
  • 18.3.2. Arytmetyka mieszana (560)
  • 18.3.3. Konwersje (561)
  • 18.3.4. Literały (564)
  • 18.3.5. Funkcje dostępowe (565)
  • 18.3.6. Funkcje pomocnicze (565)
• 18.4. Konwersja typów (567)
  • 18.4.1. Operatory konwersji (567)
  • 18.4.2. Operatory konwersji explicit (569)
  • 18.4.3. Niejednoznaczności (569)
• 18.5. Rady (571)

Rozdział 19. Operatory specjalne (573)

• 19.1. Wprowadzenie (573)
• 19.2. Operatory specjalne (573)
  • 19.2.1. Indeksowanie (573)
  • 19.2.2. Wywoływanie funkcji (574)
  • 19.2.3. Dereferencja (576)
  • 19.2.4. Inkrementacja i dekrementacja (578)
  • 19.2.5. Alokacja i dezalokacja (580)
  • 19.2.6. Literały zdefiniowane przez użytkownika (581)
• 19.3. Klasa String (584)
  • 19.3.1. Podstawowe operacje (585)
  • 19.3.2. Dostęp do znaków (585)
  • 19.3.3. Reprezentacja (586)
  • 19.3.4. Funkcje składowe (589)
  • 19.3.5. Funkcje pomocnicze (591)
  • 19.3.6. Sposoby użycia (593)
• 19.4. Przyjaciele (594)
  • 19.4.1. Znajdowanie przyjaciół (596)
  • 19.4.2. Przyjaciele i składowe (597)
• 19.5. Rady (598)

Rozdział 20. Derywacja klas (599)

• 20.1. Wprowadzenie (599)
• 20.2. Klasy pochodne (600)
  • 20.2.1. Funkcje składowe (602)
  • 20.2.2. Konstruktory i destruktory (604)
• 20.3. Hierarchie klas (604)
  • 20.3.1. Pola typów (605)
  • 20.3.2. Funkcje wirtualne (607)
  • 20.3.3. Bezpośrednia kwalifikacja (610)
  • 20.3.4. Kontrola przesłaniania (610)
  • 20.3.5. Używanie składowych klasy bazowej (614)
  • 20.3.6. Rozluźnienie zasady dotyczącej typów zwrotnych (617)
• 20.4. Klasy abstrakcyjne (619)
• 20.5. Kontrola dostępu (621)
  • 20.5.1. Składowe chronione (624)
  • 20.5.2. Dostęp do klas bazowych (625)
  • 20.5.3. Deklaracje using i kontrola dostępu (627)
• 20.6. Wskaźniki do składowych (627)
  • 20.6.1. Wskaźniki do funkcji składowych (628)
  • 20.6.2. Wskaźniki do danych składowych (630)
  • 20.6.3. Składowe bazy i klasy pochodnej (631)
• 20.7. Rady (631)

Rozdział 21. Hierarchie klas (633)

• 21.1. Wprowadzenie (633)
• 21.2. Projektowanie hierarchii klas (633)
  • 21.2.1. Dziedziczenie implementacji (634)
  • 21.2.2. Dziedziczenie interfejsu (637)
  • 21.2.3. Alternatywne implementacje (639)
  • 21.2.4. Lokalizowanie tworzenia obiektu (642)
• 21.3. Wielodziedziczenie (644)
  • 21.3.1. Wiele interfejsów (644)
  • 21.3.2. Wiele klas implementacyjnych (644)
  • 21.3.3. Rozstrzyganie niejednoznaczności (646)
  • 21.3.4. Wielokrotne użycie klasy bazowej (649)
  • 21.3.5. Wirtualne klasy bazowe (651)
  • 21.3.6. Bazy wirtualne a replikowane (655)
• 21.4. Rady (658)

Rozdział 22. Informacje o typach w czasie działania programu (659)

• 22.1. Wprowadzenie (659)
• 22.2. Poruszanie się w obrębie hierarchii klas (660)
  • 22.2.1. Rzutowanie dynamiczne (661)
  • 22.2.2. Wielodziedziczenie (664)
  • 22.2.3. Rzutowanie statyczne i dynamiczne (665)
  • 22.2.4. Odzyskiwanie interfejsu (667)
• 22.3. Podwójny polimorfizm i wizytatorzy (670)
  • 22.3.1. Podwójny polimorfizm (671)
  • 22.3.2. Wizytatorzy (673)
• 22.4. Konstrukcja i destrukcja (675)
• 22.5. Identyfikacja typów (675)
  • 22.5.1. Rozszerzone informacje o typie (677)
• 22.6. Poprawne i niepoprawne używanie RTTI (678)
• 22.7. Rady (680)

Rozdział 23. Szablony (681)

• 23.1. Wprowadzenie i przegląd (681)
• 23.2. Prosty szablon łańcucha (684)
  • 23.2.1. Definiowanie szablonu (685)
  • 23.2.2. Konkretyzacja szablonu (687)
• 23.3. Kontrola typów (688)
  • 23.3.1. Ekwiwalencja typów (689)
  • 23.3.2. Wykrywanie błędów (690)
• 23.4. Składowe szablonu klasy (691)
  • 23.4.1. Dane składowe (691)
  • 23.4.2. Funkcje składowe (692)
  • 23.4.3. Aliasy typów składowych (692)
  • 23.4.4. Składowe statyczne (692)
  • 23.4.5. Typy składowe (693)
  • 23.4.6. Szablony składowe (694)
  • 23.4.7. Przyjaciele (698)
• 23.5. Szablony funkcji (699)
  • 23.5.1. Argumenty szablonu funkcji (701)
  • 23.5.2. Dedukcja argumentów szablonu funkcji (702)
  • 23.5.3. Przeciążanie szablonów funkcji (704)
• 23.6. Aliasy szablonów (708)
• 23.7. Organizacja kodu źródłowego (709)
  • 23.7.1. Konsolidacja (711)
• 23.8. Rady (712)

Rozdział 24. Programowanie ogólne (713)

• 24.1. Wprowadzenie (713)
• 24.2. Algorytmy i uogólnianie (714)
• 24.3. Koncepcje (718)
  • 24.3.1. Odkrywanie koncepcji (718)
  • 24.3.2. Koncepcje i ograniczenia (722)
• 24.4. Konkretyzacja koncepcji (724)
  • 24.4.1. Aksjomaty (727)
  • 24.4.2. Koncepcje wieloargumentowe (728)
  • 24.4.3. Koncepcje wartości (729)
  • 24.4.4. Sprawdzanie ograniczeń (730)
  • 24.4.5. Sprawdzanie definicji szablonu (731)
• 24.5. Rady (733)

Rozdział 25. Specjalizacja (735)

• 25.1. Wprowadzenie (735)
• 25.2. Argumenty i parametry szablonu (736)
  • 25.2.1. Typy jako argumenty (736)
  • 25.2.2. Wartości jako argumenty (738)
  • 25.2.3. Operacje jako argumenty (739)
  • 25.2.4. Szablony jako argumenty (742)
  • 25.2.5. Domyślne argumenty szablonów (742)
• 25.3. Specjalizacja (744)
  • 25.3.1. Specjalizacja interfejsu (747)
  • 25.3.2. Szablon podstawowy (748)
  • 25.3.3. Porządek specjalizacji (750)
  • 25.3.4. Specjalizacja szablonu funkcji (750)
• 25.4. Rady (753)

Rozdział 26. Konkretyzacja (755)

• 26.1. Wprowadzenie (755)
• 26.2. Konkretyzacja szablonu (756)
  • 26.2.1. Kiedy konkretyzacja jest potrzebna (757)
  • 26.2.2. Ręczne sterowanie konkretyzacją (758)
• 26.3. Wiązanie nazw (759)
  • 26.3.1. Nazwy zależne (761)
  • 26.3.2. Wiązanie w miejscu definicji (762)
  • 26.3.3. Wiązanie w miejscu konkretyzacji (763)
  • 26.3.4. Wiele miejsc konkretyzacji (766)
  • 26.3.5. Szablony i przestrzenie nazw (767)
  • 26.3.6. Nadmiernie agresywne wyszukiwanie wg argumentów (768)
  • 26.3.7. Nazwy z klas bazowych (770)
• 26.4. Rady (772)

Rozdział 27. Hierarchie szablonów (773)

• 27.1. Wprowadzenie (773)
• 27.2. Parametryzacja i hierarchia (774)
  • 27.2.1. Typy generowane (776)
  • 27.2.2. Konwersje szablonów (778)
• 27.3. Hierarchie szablonów klas (779)
  • 27.3.1. Szablony jako interfejsy (780)
• 27.4. Parametry szablonowe jako klasy bazowe (781)
  • 27.4.1. Składanie struktur danych (781)
  • 27.4.2. Linearyzacja hierarchii klas (785)
• 27.5. Rady (790)

Rozdział 28. Metaprogramowanie (791)

• 28.1. Wprowadzenie (791)
• 28.2. Funkcje typowe (794)
  • 28.2.1. Aliasy typów (796)
  • 28.2.2. Predykaty typów (798)
  • 28.2.3. Wybieranie funkcji (799)
  • 28.2.4. Cechy (800)
• 28.3. Struktury sterujące (802)
  • 28.3.1. Wybieranie (802)
  • 28.3.2. Iteracja i rekurencja (805)
  • 28.3.3. Kiedy stosować metaprogramowanie (806)
• 28.4. Definicja warunkowa (807)
  • 28.4.1. Używanie Enable_if (809)
  • 28.4.2. Implementacja Enable_if (811)
  • 28.4.3. Enable_if i koncepcje (811)
  • 28.4.4. Dodatkowe przykłady użycia Enable_if (812)
• 28.5. Lista czasu kompilacji (814)
  • 28.5.1. Prosta funkcja wyjściowa (816)
  • 28.5.2. Dostęp do elementów (818)
  • 28.5.3. make_tuple (820)
• 28.6. Szablony zmienne (821)
  • 28.6.1. Bezpieczna typowo funkcja printf() (821)
  • 28.6.2. Szczegóły techniczne (824)
  • 28.6.3. Przekazywanie (825)
  • 28.6.4. Typ tuple z biblioteki standardowej (827)
• 28.7. Przykład z jednostkami układu SI (830)
  • 28.7.1. Jednostki (830)
  • 28.7.2. Wielkości (831)
  • 28.7.3. Literały jednostkowe (833)
  • 28.7.4. Funkcje pomocnicze (834)
• 28.8. Rady (836)

Rozdział 29. Projekt macierzy (837)

• 29.1. Wprowadzenie (837)
  • 29.1.1. Podstawowe zastosowania macierzy (838)
  • 29.1.2. Wymagania dotyczące macierzy (840)
• 29.2. Szablon macierzy (841)
  • 29.2.1. Konstrukcja i przypisywanie (842)
  • 29.2.2. Indeksowanie i cięcie (843)
• 29.3. Operacje arytmetyczne na macierzach (845)
  • 29.3.1. Operacje skalarne (846)
  • 29.3.2. Dodawanie (847)
  • 29.3.3. Mnożenie (848)
• 29.4. Implementacja macierzy (850)
  • 29.4.1. Wycinki (850)
  • 29.4.2. Wycinki macierzy (850)
  • 29.4.3. Matrix_ref (852)
  • 29.4.4. Inicjacja listy macierzy (853)
  • 29.4.5. Dostęp do macierzy (855)
  • 29.4.6. Macierz zerowymiarowa (857)
• 29.5. Rozwiązywanie równań liniowych (858)
  • 29.5.1. Klasyczna eliminacja Gaussa (859)
  • 29.5.2. Znajdowanie elementu centralnego (860)
  • 29.5.3. Testowanie (861)
  • 29.5.4. Połączone operacje (862)
• 29.6. Rady (864)

CZĘŚĆ IV. BIBLIOTEKA STANDARDOWA (865)

Rozdział 30. Przegląd zawartości biblioteki standardowej (867)

• 30.1. Wprowadzenie (867)
  • 30.1.1. Narzędzia biblioteki standardowej (868)
  • 30.1.2. Kryteria projektowe (869)
  • 30.1.3. Styl opisu (870)
• 30.2. Nagłówki (871)
• 30.3. Wsparcie dla języka (875)
  • 30.3.1. Wsparcie dla list inicjacyjnych (876)
  • 30.3.2. Wsparcie dla zakresowej pętli for (876)
• 30.4. Obsługa błędów (877)
  • 30.4.1. Wyjątki (877)
  • 30.4.2. Asercje (882)
  • 30.4.3. system_error (882)
• 30.5. Rady (892)

Rozdział 31. Kontenery STL (893)

• 31.1. Wprowadzenie (893)
• 31.2. Przegląd kontenerów (893)
  • 31.2.1. Reprezentacja kontenera (896)
  • 31.2.2. Wymagania dotyczące elementów (898)
• 31.3. Przegląd operacji (901)
  • 31.3.1. Typy składowe (904)
  • 31.3.2. Konstruktory, destruktory i przypisania (904)
  • 31.3.3. Rozmiar i pojemność (906)
  • 31.3.4. Iteratory (907)
  • 31.3.5. Dostęp do elementów (908)
  • 31.3.6. Operacje stosowe (908)
  • 31.3.7. Operacje listowe (909)
  • 31.3.8. Inne operacje (910)
• 31.4. Kontenery (910)
  • 31.4.1. vector (911)
  • 31.4.2. Listy (915)
  • 31.4.3. Kontenery asocjacyjne (917)
• 31.5. Adaptacje kontenerów (929)
  • 31.5.1. Stos (929)
  • 31.5.2. Kolejka (931)
  • 31.5.3. Kolejka priorytetowa (931)
• 31.6. Rady (932)

Rozdział 32. Algorytmy STL (935)

• 32.1. Wprowadzenie (935)
• 32.2. Algorytmy (935)
  • 32.2.1. Sekwencje (936)
• 32.3. Argumenty zasad (938)
  • 32.3.1. Złożoność (939)
• 32.4. Algorytmy nie modyfikujące sekwencji (940)
  • 32.4.1. for_each() (940)
  • 32.4.2. Predykaty sekwencji (940)
  • 32.4.3. count() (940)
  • 32.4.4. find() (941)
  • 32.4.5. equal() i mismatch() (942)
  • 32.4.6. search() (942)
• 32.5. Algorytmy modyfikujące sekwencje (943)
  • 32.5.1. copy() (944)
  • 32.5.2. unique() (945)
  • 32.5.3. remove() i replace() (946)
  • 32.5.4. rotate(), random_shuffle() oraz partition() (947)
  • 32.5.5. Permutacje (948)
  • 32.5.6. fill() (948)
  • 32.5.7. swap() (949)
• 32.6. Sortowanie i wyszukiwanie (950)
  • 32.6.1. Wyszukiwanie binarne (952)
  • 32.6.2. merge() (954)
  • 32.6.3. Algorytmy działające na zbiorach (954)
  • 32.6.4. Sterty (955)
  • 32.6.5. lexicographical_compare() (956)
• 32.7. Element minimalny i maksymalny (957)
• 32.8. Rady (958)

Rozdział 33. Iteratory STL (959)

• 33.1. Wprowadzenie (959)
  • 33.1.1. Model iteratorów (959)
  • 33.1.2. Kategorie iteratorów (961)
  • 33.1.3. Cechy iteratorów (962)
  • 33.1.4. Operacje iteratorów (964)
• 33.2. Adaptacje iteratorów (965)
  • 33.2.1. Iterator odwrotny (966)
  • 33.2.2. Iteratory wstawiające (968)
  • 33.2.3. Iteratory przenoszące (969)
• 33.3. Zakresowe funkcje dostępowe (970)
• 33.4. Obiekty funkcyjne (971)
• 33.5. Adaptacje funkcji (972)
  • 33.5.1. bind() (972)
  • 33.5.2. mem_fn() (974)
  • 33.5.3. function (974)
• 33.6. Rady (976)

Rozdział 34. Pamięć i zasoby (977)

• 34.1. Wprowadzenie (977)
• 34.2. „Prawie kontenery” (977)
  • 34.2.1. array (978)
  • 34.2.2. bitset (981)
  • 34.2.3. vector (985)
  • 34.2.4. Krotki (986)
• 34.3. Wskaźniki do zarządzania pamięcią (990)
  • 34.3.1. unique_ptr (990)
  • 34.3.2. shared_ptr (993)
  • 34.3.3. weak_ptr (996)
• 34.4. Alokatory (998)
  • 34.4.1. Alokator domyślny (1000)
  • 34.4.2. Cechy alokatorów (1001)
  • 34.4.3. Cechy wskaźników (1002)
  • 34.4.4. Alokatory zakresowe (1003)
• 34.5. Interfejs odśmiecacza (1004)
• 34.6. Pamięć niezainicjowana (1007)
  • 34.6.1. Bufory tymczasowe (1007)
  • 34.6.2. raw_storage_iterator (1008)
• 34.7. Rady (1009)

Rozdział 35. Narzędzia pomocnicze (1011)

• 35.1. Wprowadzenie (1011)
• 35.2. Czas (1011)
  • 35.2.1. duration (1012)
  • 35.2.2. time_point (1015)
  • 35.2.3. Zegary (1017)
  • 35.2.4. Cechy czasu (1018)
• 35.3. Działania arytmetyczne na liczbach wymiernych w czasie kompilacji (1019)
• 35.4. Funkcje typowe (1020)
  • 35.4.1. Cechy typów (1020)
  • 35.4.2. Generatory typów (1025)
• 35.5. Drobne narzędzia (1030)
  • 35.5.1. move() i forward() (1030)
  • 35.5.2. swap() (1031)
  • 35.5.3. Operatory relacyjne (1031)
  • 35.5.4. Porównywanie i mieszanie type_info (1032)
• 35.6. Rady (1033)

Rozdział 36. Łańcuchy (1035)

• 36.1. Wprowadzenie (1035)
• 36.2. Klasyfikacja znaków (1035)
  • 36.2.1. Funkcje klasyfikacji (1035)
  • 36.2.2. Cechy znaków (1036)
• 36.3. Łańcuchy (1038)
  • 36.3.1. Typ string a łańcuchy w stylu C (1039)
  • 36.3.2. Konstruktory (1040)
  • 36.3.3. Operacje podstawowe (1042)
  • 36.3.4. Łańcuchowe wejście i wyjście (1044)
  • 36.3.5. Konwersje numeryczne (1044)
  • 36.3.6. Operacje w stylu biblioteki STL (1046)
  • 36.3.7. Rodzina funkcji find (1048)
  • 36.3.8. Podłańcuchy (1049)
• 36.4. Rady (1050)

Rozdział 37. Wyrażenia regularne (1053)

• 37.1. Wyrażenia regularne (1053)
  • 37.1.1. Notacja wyrażeń regularnych (1054)
• 37.2. regex (1059)
  • 37.2.1. Wyniki dopasowywania (1061)
  • 37.2.2. Formatowanie (1063)
• 37.3. Funkcje wyrażeń regularnych (1064)
  • 37.3.1. regex_match() (1064)
  • 37.3.2. regex_search() (1066)
  • 37.3.3. regex_replace() (1067)
• 37.4. Iteratory wyrażeń regularnych (1068)
  • 37.4.1. regex_iterator (1068)
  • 37.4.2. regex_token_iterator (1070)
• 37.5. regex_traits (1072)
• 37.6. Rady (1073)

Rozdział 38. Strumienie wejścia i wyjścia (1075)

• 38.1. Wprowadzenie (1075)
• 38.2. Hierarchia strumieni wejścia i wyjścia (1077)
  • 38.2.1. Strumienie plikowe (1078)
  • 38.2.2. Strumienie łańcuchowe (1079)
• 38.3. Obsługa błędów (1081)
• 38.4. Operacje wejścia i wyjścia (1082)
  • 38.4.1. Operacje wejściowe (1083)
  • 38.4.2. Operacje wyjściowe (1086)
  • 38.4.3. Manipulatory (1088)
  • 38.4.4. Stan strumienia (1089)
  • 38.4.5. Formatowanie (1094)
• 38.5. Iteratory strumieniowe (1101)
• 38.6. Buforowanie (1102)
  • 38.6.1. Strumienie wyjściowe i bufory (1105)
  • 38.6.2. Strumienie wejściowe i bufory (1106)
  • 38.6.3. Iteratory buforów (1107)
• 38.7. Rady (1109)

Rozdział 39. Lokalizacje (1111)

• 39.1. Różnice kulturowe (1111)
• 39.2. Klasa locale (1114)
  • 39.2.1. Lokalizacje nazwane (1116)
  • 39.2.2. Porównywanie łańcuchów (1120)
• 39.3. Klasa facet (1120)
  • 39.3.1. Dostęp do faset w lokalizacji (1121)
  • 39.3.2. Definiowanie prostej fasety (1122)
  • 39.3.3. Zastosowania lokalizacji i faset (1125)
• 39.4. Standardowe fasety (1125)
  • 39.4.1. Porównywanie łańcuchów (1127)
  • 39.4.2. Formatowanie liczb (1131)
  • 39.4.3. Formatowanie kwot pieniężnych (1136)
  • 39.4.4. Formatowanie daty i godziny (1141)
  • 39.4.5. Klasyfikacja znaków (1144)
  • 39.4.6. Konwersja kodów znaków (1147)
  • 39.4.7. Wiadomości (1151)
• 39.5. Interfejsy pomocnicze (1155)
  • 39.5.1. Klasyfikacja znaków (1155)
  • 39.5.2. Konwersje znaków (1156)
  • 39.5.3. Konwersje łańcuchów (1156)
  • 39.5.4. Buforowanie konwersji (1157)
• 39.6. Rady (1158)

Rozdział 40. Liczby (1159)

• 40.1. Wprowadzenie (1159)
• 40.2. Granice liczbowe (1160)
  • 40.2.1. Makra ograniczające (1162)
• 40.3. Standardowe funkcje matematyczne (1163)
• 40.4. Liczby zespolone (1164)
• 40.5. Tablica numeryczna valarray (1166)
  • 40.5.1. Konstruktory i przypisania (1166)
  • 40.5.2. Indeksowanie (1168)
  • 40.5.3. Operacje (1169)
  • 40.5.4. Wycinki (1172)
  • 40.5.5. slice_array (1174)
  • 40.5.6. Uogólnione wycinki (1175)
• 40.6. Uogólnione algorytmy numeryczne (1176)
  • 40.6.1. Algorytm accumulate() (1177)
  • 40.6.2. Algorytm inner_product() (1177)
  • 40.6.3. Algorytmy partial_sum() i adjacent_difference() (1178)
  • 40.6.4. Algorytm iota() (1179)
• 40.7. Liczby losowe (1180)
  • 40.7.1. Mechanizmy (1182)
  • 40.7.2. Urządzenie losowe (1184)
  • 40.7.3. Rozkłady (1185)
  • 40.7.4. Losowanie liczb w stylu C (1189)
• 40.8. Rady (1189)

Rozdział 41. Współbieżność (1191)

• 41.1. Wprowadzenie (1191)
• 41.2. Model pamięci (1193)
  • 41.2.1. Lokalizacje pamięci (1194)
  • 41.2.2. Zmienianie kolejności instrukcji (1195)
  • 41.2.3. Porządek pamięci (1196)
  • 41.2.4. Wyścigi do danych (1197)
• 41.3. Konstrukcje atomowe (1198)
  • 41.3.1. Typy atomowe (1201)
  • 41.3.2. Flagi i bariery (1205)
• 41.4. Słowo kluczowe volatile (1207)
• 41.5. Rady (1207)

Rozdział 42. Wątki i zadania (1209)

• 42.1. Wprowadzenie (1209)
• 42.2. Wątki (1210)
  • 42.2.1. Tożsamość (1211)
  • 42.2.2. Konstrukcja (1212)
  • 42.2.3. Destrukcja (1213)
  • 42.2.4. Funkcja join() (1214)
  • 42.2.5. Funkcja detach() (1215)
  • 42.2.6. Przestrzeń nazw this_thread (1217)
  • 42.2.7. Likwidowanie wątku (1218)
  • 42.2.8. Dane lokalne wątku (1218)
• 42.3. Unikanie wyścigów do danych (1220)
  • 42.3.1. Muteksy (1220)
  • 42.3.2. Wiele blokad (1228)
  • 42.3.3. Funkcja call_once() (1230)
  • 42.3.4. Zmienne warunkowe (1231)
• 42.4. Współbieżność zadaniowa (1235)
  • 42.4.1. Typy future i promise (1236)
  • 42.4.2. Typ promise (1237)
  • 42.4.3. Typ packaged_task (1238)
  • 42.4.4. Typ future (1241)
  • 42.4.5. Typ shared_future (1244)
  • 42.4.6. Funkcja async() (1245)
  • 42.4.7. Przykład równoległej funkcji find() (1247)
• 42.5. Rady (1251)

Rozdział 43. Biblioteka standardowa C (1253)

• 43.1. Wprowadzenie (1253)
• 43.2. Pliki (1253)
• 43.3. Rodzina printf() (1254)
• 43.4. Łańcuchy w stylu C (1259)
• 43.5. Pamięć (1260)
• 43.6. Data i godzina (1261)
• 43.7. Itd. (1264)
• 43.8. Rady (1266)

Rozdział 44. Zgodność (1267)

• 44.1. Wprowadzenie (1267)
• 44.2. Rozszerzenia C++11 (1268)
  • 44.2.1. Narzędzia językowe (1268)
  • 44.2.2. Składniki biblioteki standardowej (1269)
  • 44.2.3. Elementy wycofywane (1270)
  • 44.2.4. Praca ze starszymi implementacjami C++ (1271)
• 44.3. Zgodność C i C++ (1271)
  • 44.3.1. C i C++ to rodzeństwo (1271)
  • 44.3.2. „Ciche” różnice (1273)
  • 44.3.3. Kod C nie będący kodem C++ (1274)
  • 44.3.4. Kod C++ nie będący kodem C (1277)
• 44.4. Rady (1279)

Skorowidz (1281)