Najlepsze źródło informacji o C++!

Język C++. Szkoła programowania to starannie sprawdzony, sumiennie przygotowany i kompletny przewodnik po programowaniu w C++, przeznaczony dla programistów. Ten klasyczny już materiał pomocniczy dla wykładowców uczy zasad programowania, począwszy od kodu strukturalnego i projektowania wedle metody dekompozycji i analizy, przez klasy, dziedziczenie, szablony i wyjątki, po wyrażenia lambda, inteligentne wskaźniki i semantykę przeniesienia. Stephen Prata jako autor i wykładowca proponuje przemyślane, przejrzyste i wnikliwe wprowadzenie do języka C++. Wraz z mechanizmami samego języka omawia fundamentalne pojęcia i techniki programowania.

Szóste wydanie książki zostało uaktualnione i rozszerzone o omówienie elementów wprowadzonych do języka w nowym standardzie C++11. Książka przyda się nie tylko studentom klas informatycznych, ale również programistom biegłym w innych językach programowania, którzy chcieliby poznać język C++ lub pogłębić swoją wiedzę dotyczącą niuansów stosowania tego języka.

     • Kompilatory języka C++

• Struktura programu
• Proste i złożone typy danych
• Pętle i instrukcje warunkowe
• Definiowanie funkcji i korzystanie z nich
• Model pamięci w C++
• Podstawowe elementy programowania obiektowego -- obiekty i klasy
• Dynamiczne przydzielanie pamięci
• Mechanizmy dziedziczenia
• Obsługa wyjątków
• Biblioteka STL
• Operacje wejścia-wyjścia

Poznaj najważniejsze zasady programowania w C++.

Spis treści:

Rozdział 1 Zaczynamy (11)

• Nauka C++ - co nas czeka? (11)
• Pochodzenie języka C++ - krótka historia (12)
  • Język C (13)
  • Filozofia programowania w C (13)
  • Zmiana w C++ - programowanie obiektowe (15)
  • C++ i programowanie ogólne (16)
  • Pochodzenie C++ (16)
• Przenośność i standardy (18)
• Mechanika tworzenia programu (20)
  • Pisanie kodu źródłowego (21)
  • Kompilacja i konsolidacja (22)
• Podsumowanie (27)

Rozdział 2 Pierwszy program w C++ (29)

• C++ - początek (29)
  • Funkcja main() (31)
  • Komentarze w C++ (34)
  • Preprocesor i plik iostream (35)
  • Nazwy plików nagłówkowych (36)
  • Przestrzenie nazw (37)
  • Wypisywanie danych - cout (38)
  • Formatowanie kodu źródłowego C++ (41)
• Instrukcje C++ (43)
  • Instrukcje deklaracji i zmienne (43)
  • Instrukcja przypisania (45)
  • Nowa sztuczka z cout (46)
• Inne instrukcje C++ (47)
  • Użycie obiektu cin (48)
  • Złączanie za pomocą cout (48)
  • cin i cout - klasy po raz pierwszy (49)
• Funkcje (51)
  • Użycie funkcji zwracającej wartość (51)
  • Odmiany funkcji (55)
  • Funkcje definiowane przez użytkownika (55)
  • Funkcje użytkownika zwracające wartość (59)
  • Dyrektywa using w programach z wieloma funkcjami (61)
• Podsumowanie (63)
• Pytania sprawdzające (63)
• Ćwiczenia programistyczne (64)

Rozdział 3 Dane (67)

• Zmienne proste (68)
  • Nazwy zmiennych (68)
  • Typy całkowitoliczbowe (70)
  • Typy short, int i long (70)
  • Typy bez znaku (75)
  • Dobór właściwego typu (78)
  • Stałe całkowitoliczbowe (79)
  • Jak C++ ustala typ stałej? (81)
  • Typ char - znaki i małe liczby całkowite (81)
  • Typ danych bool (89)
• Kwalifikator const (90)
• Liczby zmiennoprzecinkowe (91)
  • Zapis liczb zmiennoprzecinkowych (92)
  • Zmiennoprzecinkowe typy danych (93)
  • Stałe zmiennoprzecinkowe (96)
  • Zalety i wady liczb zmiennoprzecinkowych (96)
• Operatory arytmetyczne C++ (97)
  • Kolejność działań - priorytety operatorów i łączność (99)
  • Odmiany dzielenia (100)
  • Operator modulo (102)
  • Konwersje typów (103)
• Podsumowanie (109)
• Pytania sprawdzające (110)
• Ćwiczenia programistyczne (110)

Rozdział 4 Typy złożone (113)

• Tablice w skrócie (114)
  • Uwagi o programie (116)
  • Inicjalizacja tablic (117)
• Łańcuchy (118)
  • Łączenie stałych łańcuchowych (120)
  • Łańcuchy w tablicy (120)
  • Problemy z wprowadzaniem łańcuchów znakowych (122)
  • Wczytywanie łańcuchów znakowych wierszami (124)
  • Mieszanie w danych wejściowych łańcuchów i liczb (128)
• Klasa string - wprowadzenie (130)
  • Przypisanie, konkatenacja i dołączanie (131)
  • Inne operacje klasy string (133)
  • Klasa string a wejście i wyjście (135)
• Struktury (137)
  • Użycie struktury w programie (139)
  • Czy w strukturze można użyć pola typu string? (142)
  • Inne cechy struktur (142)
  • Tablice struktur (144)
  • Pola bitowe (145)
• Unie (146)
• Typy wyliczeniowe (148)
  • Ustawianie wartości enumeratorów (150)
  • Zakresy wartości w typach wyliczeniowych (150)
• Wskaźniki i różne drobiazgi (151)
  • Deklarowanie i inicjalizacja wskaźników (154)
  • Niebezpieczeństwa związane ze wskaźnikami (157)
  • Wskaźniki i liczby (157)
  • Użycie operatora new do alokowania pamięci (158)
  • Zwalnianie pamięci za pomocą delete (160)
  • Użycie new do tworzenia tablic dynamicznych (161)
• Wskaźniki, tablice i arytmetyka wskaźników (164)
  • Uwagi o programie (166)
  • Wskaźniki i łańcuchy (170)
  • Użycie new do tworzenia struktur dynamicznych (175)
  • Alokacja pamięci: automatyczna, statyczna i dynamiczna (179)
• Podsumowanie (181)
• Pytania sprawdzające (182)
• Ćwiczenia programistyczne (183)

Rozdział 5 Pętle i wyrażenia relacyjne (185)

• Pętle for (186)
  • Elementy pętli for (187)
  • Wracamy do pętli for (194)
  • Zmiana wielkości kroku (195)
  • Pętla for i łańcuchy znakowe (196)
  • Operatory inkrementacji (++) i dekrementacji (--) (197)
  • Efekty uboczne i punkty odniesienia (199)
  • Formy przedrostkowe a formy przyrostkowe (199)
  • Operatory inkrementacji i dekrementacji a wskaźniki (200)
  • Złożone operatory przypisania (201)
  • Instrukcje złożone czyli bloki (202)
  • Przecinek jako operator (i pewne sztuczki składniowe) (204)
• Wyrażenia relacyjne (207)
  • Bardzo typowy błąd (208)
  • Porównywanie łańcuchów w stylu C (211)
  • Porównywanie łańcuchów klasy string (213)
• Pętla while (215)
  • Uwagi o programie (216)
  • Pętla for a pętla while (217)
  • Chwileczkę - tworzymy pętlę opóźnienia (219)
• Pętla do while (221)
• Pętle i wprowadzanie danych tekstowych (224)
  • Najprostsza wersja cin (224)
  • cin.get(char) na odsiecz (225)
  • Która cin.get()? (227)
  • Koniec pliku (227)
  • Jeszcze inna wersja cin.get() (231)
• Pętle zagnieżdżone i dwuwymiarowe tablice (234)
  • Inicjalizacja tablic dwuwymiarowych (236)
• Podsumowanie (238)
• Pytania sprawdzające (239)
• Ćwiczenia programistyczne (230)

Rozdział 6 Instrukcje warunkowe i operatory logiczne (243)

• Instrukcja if (243)
  • Instrukcja if else (245)
  • Formatowanie instrukcji if else (247)
  • Konstrukcja if else if else (248)
• Wyrażenia logiczne (250)
  • Logiczny operator alternatywy - || (250)
  • Logiczny operator koniunkcji - && (252)
  • Operator negacji logicznej - ! (257)
  • O operatorach logicznych (259)
  • Zapis alternatywny (260)
• Biblioteka cctype (261)
• Operator ?: (263)
• Instrukcja switch (265)
  • Użycie enumeratorów jako etykiet (269)
  • switch versus if else (270)
• Instrukcje break i continue (270)
  • Uwagi o programie (272)
• Pętle wczytywania liczb (273)
  • Uwagi o programie (277)
• Proste wejście-wyjście z pliku (277)
  • Tekstowe wejście-wyjście i pliki tekstowe (277)
  • Zapis do pliku tekstowego (279)
  • Odczyt danych z pliku tekstowego (283)
• Podsumowanie (288)
• Pytania sprawdzające (289)
• Ćwiczenia programistyczne (291)

Rozdział 7 Funkcje - składniki programów w C++ (295)

• Funkcje w skrócie (295)
  • Definiowanie funkcji (296)
  • Prototypowanie i wywoływanie funkcji (299)
• Parametry funkcji i przekazywanie przez wartość (302)
  • Wiele parametrów (304)
  • Jeszcze jedna funkcja dwuargumentowa (306)
• Funkcje i tablice (309)
  • Jak wskaźniki umożliwiają tworzenie funkcji przetwarzających tablice? (310)
  • Skutki użycia tablic jako parametrów (311)
  • Dodatkowe przykłady funkcji i tablic (314)
  • Funkcje korzystające z zakresów tablic (320)
  • Wskaźniki i modyfikator const (322)
• Funkcje i tablice dwuwymiarowe (325)
• Funkcje i łańcuchy w stylu C (327)
  • Funkcje z łańcuchami w stylu C jako parametrami (327)
  • Funkcje zwracające łańcuchy w formacie C (329)
• Funkcje i struktury (331)
  • Przekazywanie i zwracanie struktur (332)
  • Inny przykład użycia funkcji i struktur (334)
  • Przekazywanie adresu struktury (339)
• Funkcje i obiekty klasy string (341)
• Rekurencja (343)
  • Rekurencja w pojedynczym wywołaniu (343)
  • Rekurencja w wielu wywołaniach (345)
• Wskaźniki na funkcje (347)
  • Wskaźniki na funkcje - podstawy (347)
  • Przykład użycia wskaźników na funkcje (350)
• Podsumowanie (351)
• Pytania sprawdzające (352)
• Ćwiczenia programistyczne (353)

Rozdział 8 Funkcje - zagadnienia zaawansowane (357)

• Funkcje inline (357)
• Zmienne referencyjne (361)
  • Tworzenie zmiennej referencyjnej (361)
  • Referencje jako parametry funkcji (364)
  • Właściwości referencji (368)
  • Ostrożnie ze zwracaniem referencji (375)
  • Użycie referencji z obiektami (376)
  • Obiekty po raz wtóry - obiekty, dziedziczenie i referencje (380)
  • Kiedy korzystać z referencji jako parametrów? (383)
• Parametry domyślne (384)
  • Uwagi o programie (387)
• Przeciążanie funkcji (387)
  • Przykład przeciążania funkcji (390)
  • Kiedy korzystać z przeciążania funkcji? (392)
• Szablony funkcji (393)
  • Przeciążone szablony (397)
  • Specjalizacje jawne (399)
  • Tworzenie egzemplarzy i specjalizacje (404)
  • Którą wersję funkcji kompilator wybierze? (406)
• Podsumowanie (412)
• Pytania sprawdzające (413)
• Ćwiczenia programistyczne (414)

Rozdział 9 Model pamięci i przestrzenie nazw (417)

• Kompilacja rozłączna (417)
• Czas życia, zasięg i łączenie (424)
  • Zasięg i łączenie (425)
  • Przydział automatyczny (425)
  • Zmienne statyczne (431)
  • Specyfikatory i kwalifikatory (443)
  • Łączenie a funkcje (445)
  • Łączenie językowe (446)
  • Kategorie przydziału a przydział dynamiczny (447)
• Miejscowa wersja operatora new (448)
  • O programie (451)
• Przestrzenie nazw (452)
  • Tradycyjne przestrzenie nazw języka C++ (452)
  • Nowe mechanizmy przestrzeni nazw (454)
  • Przestrzenie nazw - przykład (463)
  • Przyszłość przestrzeni nazw (468)
• Podsumowanie (468)
• Pytania sprawdzające (469)
• Ćwiczenia programistyczne (473)

Rozdział 10 Obiekty i klasy (477)

• Programowanie proceduralne a programowanie obiektowe (478)
• Klasy a abstrakcje (479)
  • Czym jest typ? (479)
  • Klasy w języku C++ (480)
  • Implementowanie metod klas (485)
  • Stosowanie klas (491)
  • Podsumowanie poznanych wiadomości (495)
• Konstruktory i destruktory (496)
  • Deklarowanie i definiowanie konstruktorów (497)
  • Stosowanie konstruktorów (499)
  • Konstruktory domyślne (500)
  • Destruktory (501)
  • Ulepszenia klasy Stock (502)
  • Konstruktory i destruktory - podsumowanie (511)
• Tożsamość obiektu - wskaźnik this (512)
• Tablice obiektów (519)
• Jeszcze o interfejsach i implementacji (522)
  • Zasięg klasy (524)
• Stałe zasięgu klasy (525)
• Abstrakcyjne typy danych (527)
• Podsumowanie (533)
• Pytania sprawdzające (534)
• Ćwiczenia programistyczne (534)

Rozdział 11 Stosowanie klas (539)

• Przeciążanie operatorów (540)
• Raz, dwa, trzy - próba przeciążenia operatora (541)
  • Dodatkowy operator dodawania (545)
  • Ograniczenia przeciążania operatorów (549)
  • Jeszcze o przeciążaniu operatorów (551)
• Przyjaciele najważniejsi (554)
  • Deklarowanie przyjaźni (556)
  • Typowa przyjaźń - przeciążanie operatora << (557)
• Przeciążanie operatorów - metody kontra funkcje nieskładowe (565)
• Przeciążania ciąg dalszy - klasa Vector (566)
  • Składowa kodująca stan obiektu (575)
  • Przeciążanie operatorów arytmetycznych dla klasy Vector (577)
  • Nota implementacyjna (580)
  • Wektorowe błądzenie losowe (580)
• Automatyczne konwersje i rzutowanie typów klas (585)
  • O programie (590)
  • Funkcje konwersji (591)
  • Konwersja a zaprzyjaźnienie (597)
• Podsumowanie (601)
• Pytania sprawdzające (603)
• Ćwiczenia programistyczne (603)

Rozdział 12 Klasy a dynamiczny przydział pamięci (607)

• Klasy a pamięć dynamiczna (608)
  • Powtórka z pamięci dynamicznej i statyczne składowe klas (608)
  • Niejawne metody klasy (618)
  • Nowa, ulepszona klasa - String (628)
  • O czym należy pamiętać, stosując new w konstruktorach? (641)
  • Słów parę o zwracaniu obiektów (643)
  • Wskaźniki obiektów (647)
  • Powtórka z poznanych technik (659)
• Symulacja kolejki (661)
  • Klasa kolejki (662)
  • Klasa klienta (673)
  • Symulacja (677)
• Podsumowanie (682)
• Pytania sprawdzające (684)
• Ćwiczenia programistyczne (686)

Rozdział 13 Klasy i dziedziczenie (691)

• Prosta klasa bazowa (692)
  • Dziedziczenie (694)
  • Konstruktory - zagadnienia związane z poziomem dostępu (696)
  • Korzystanie z klasy pochodnej (699 )
  • Relacje między klasą pochodną a bazową (702)
• Dziedziczenie - relacja jest-czymś (705)
• Polimorficzne dziedziczenie publiczne (706)
  • Tworzenie klas Brass oraz BrassPlus (707)
  • Wiązanie statyczne i dynamiczne (721)
  • Zgodność typów wskaźnikowych i referencyjnych (721)
  • Wirtualne funkcje składowe i wiązanie dynamiczne (723)
  • Co trzeba wiedzieć o metodach wirtualnych? (726)
• Kontrola dostępu - poziom chroniony (729)
• Abstrakcyjne klasy bazowe (732)
  • Stosowanie abstrakcyjnych klas bazowych (735)
  • Filozofia abstrakcyjnych klas bazowych (740)
• Dziedziczenie i dynamiczny przydział pamięci (740)
  • Przypadek pierwszy - klasa pochodna bez dynamicznego przydziału pamięci (740)
  • Przypadek drugi - klasa pochodna z dynamicznym przydziałem pamięci (742)
  • Przykład dziedziczenia z wykorzystaniem dynamicznego przydziału pamięci oraz funkcji zaprzyjaźnionych (744)
• Projektowanie klas - przegląd zagadnień (750)
  • Funkcje składowe automatycznie generowane przez kompilator (750)
  • Inne metody (754)
  • Dziedziczenie publiczne (756)
  • Funkcje klasy - podsumowanie (761)
• Podsumowanie (762)
• Pytania sprawdzające (762)
• Ćwiczenia (764)

Rozdział 14 Wielokrotne użycie kodu w C++ (767)

• Klasy ze składowymi w postaci obiektów (768)
  • Krótka charakterystyka klasy valarray (768)
  • Projekt klasy Student (769)
  • Przykładowa klasa Student (771)
• Dziedziczenie prywatne (779)
  • Nowa wersja klasy Student (780)
• Dziedziczenie wielokrotne (792)
  • Podwójne egzemplarze klasy Worker (798)
  • Podwójne metody (802)
  • Przegląd zagadnień związanych z dziedziczeniem wielokrotnym (814)
• Szablony klas (815)
  • Definiowanie szablonu klasy (815)
  • Korzystanie z szablonu klasy (819)
  • Analiza szablonu klasy (822)
  • Szablon tablicy i argumenty niebędące typami (828)
  • Elastyczność szablonów (831)
  • Specjalizacja szablonu (835)
  • Szablony jako składowe (838)
  • Szablony jako parametry (841)
  • Szablony klas i zaprzyjaźnienie (844)
• Podsumowanie (852)
• Pytania sprawdzające (854)
• Ćwiczenia programistyczne (856)

Rozdział 15 Zaprzyjaźnienie, wyjątki i nie tylko (863)

• Zaprzyjaźnienie (863)
  • Klasy zaprzyjaźnione (864)
  • Zaprzyjaźnione funkcje składowe (869)
  • Inne relacje przyjaźni (873)
• Klasy zagnieżdżone (875)
  • Dostęp do klas zagnieżdżonych (877)
  • Zagnieżdżanie w szablonie (879)
• Wyjątki (883)
  • Wywoływanie funkcji abort() (884)
  • Zwracanie kodu błędu (885)
  • Mechanizm wyjątków (887)
  • Wyjątki w postaci obiektów (891)
  • Rozwijanie stosu (895)
  • Inne właściwości wyjątków (901)
  • Klasa exception (904)
  • Wyjątki, klasy i dziedziczenie (909)
  • Problemy z wyjątkami (915)
  • Ostrożnie z wyjątkami (918)
• RTTI (920)
  • Po co nam RTTI? (920)
  • Jak działa RTTI? (921)
• Operatory rzutowania typu (930)
• Podsumowanie (934)
• Pytania sprawdzające (935)
• Ćwiczenia programistyczne (937)

Rozdział 16 Klasa string oraz biblioteka STL (939)

• Klasa string (939)
  • Tworzenie obiektu string (940)
  • Wprowadzanie danych do obiektów string (944)
  • Używanie obiektów string (947)
  • Co jeszcze oferuje klasa string? (953)
• Klasa auto_ptr (956)
  • Używanie obiektów klasy auto_ptr (957)
  • Zagadnienia związane z klasą auto_ptr (960)
• Biblioteka STL (961)
  • Szablon klasy vector (962)
  • Metody klasy vector (965)
  • Inne możliwości klasy vector (970)
• Programowanie generyczne (975)
  • Do czego potrzebne są iteratory? (975)
  • Rodzaje iteratorów (979)
  • Hierarchia iteratorów (983)
  • Pojęcia, uściślenia i modele (984)
  • Rodzaje kontenerów (991)
  • Kontenery asocjacyjne (1002)
• Obiekty funkcyjne (funktory) (1009)
  • Pojęcia związane z funktorami (1011)
  • Funktory predefiniowane (1014)
  • Funktory adaptowalne i adaptatory funkcji (1016)
• Algorytmy (1019)
  • Grupy algorytmów (1019)
  • Ogólne właściwości algorytmów (1020)
  • Biblioteka STL i klasa string (1022)
  • Funkcje a metody kontenerów (1023)
  • Używanie biblioteki STL (1025)
• Inne biblioteki (1029)
  • Klasy vector oraz valarray (1030)
• Podsumowanie (1036)
• Pytania sprawdzające (1038)
• Ćwiczenia programistyczne (1039)

Rozdział 17 Obsługa wejścia, wyjścia oraz plików (1041)

• Ogólna charakterystyka obsługi wejścia-wyjścia w języku C++ (1042)
  • Strumienie i bufory (1043)
  • Strumienie i bufory a plik iostream (1045)
  • Przekierowanie (1047)
• Realizacja operacji wyjścia z wykorzystaniem obiektu cout (1048)
  • Przeciążony operator << (1049)
  • Inne metody klasy ostream (1052)
  • Opróżnianie bufora wyjściowego (1055)
  • Formatowanie danych wyjściowych za pomocą obiektu cout (1056)
• Realizacja operacji wejścia z wykorzystaniem obiektu cin (1075)
  • Jak operator >> obiektu cin "widzi" dane wejściowe (1077)
  • Stany strumienia (1079)
  • Inne metody klasy istream (1084)
  • Pozostałe metody klasy istream (1093)
• Wejście-wyjście plikowe (1098)
  • Proste operacje wejścia-wyjścia plikowego (1098)
  • Kontrola strumienia i metoda is_open() (1102)
  • Otwieranie wielu plików (1103)
  • Przetwarzanie argumentów wiersza polecenia (1104)
  • Tryby otwarcia pliku (1107)
  • Dostęp swobodny (1118)
• Formatowanie wewnętrzne (1128)
• I co dalej? (1130)
• Podsumowanie (1131)
• Pytania sprawdzające (1133)
• Ćwiczenia programistyczne (1134)

Dodatek A Systemy liczbowe (1139)

• Liczby dziesiętne (o podstawie 10) (1139)
• Liczby całkowite ósemkowe (o podstawie 8) (1139)
• Liczby szesnastkowe (1140)
• Liczby dwójkowe (o podstawie 2) (1141)
• Zapis dwójkowy a szesnastkowy (1141)

Dodatek B Słowa zastrzeżone języka C++ (1145)

• Słowa kluczowe języka C++ (1145)
• Leksemy alternatywne (1146)
• Nazwy zastrzeżone bibliotek języka C++ (1146)

Dodatek C Zestaw znaków ASCII (1149)
Dodatek D Priorytety operatorów (1155)
Dodatek E Inne operatory (1159)

• Operatory bitowe (1159)
  • Operatory przesunięcia (1159)
  • Bitowe operatory logiczne (1161)
  • Alternatywne reprezentacje operatorów bitowych (1164)
  • Kilka typowych technik wykorzystujących operatory bitowe (1164)
• Operatory dereferencji składowych (1166)

Dodatek F Klasa szablonowa string (1171)

• Trzynaście typów i stała (1172)
• Informacje o danych, konstruktory i różne drobiazgi (1173)
  • Konstruktory domyślne (1175)
  • Konstruktory wykorzystujące tablice (1175)
  • Konstruktory wykorzystujące fragment tablicy (1176)
  • Konstruktory kopiujące (1176)
  • Konstruktory wykorzystujące n kopii znaku (1177)
  • Konstruktory wykorzystujące zakres (1178)
  • Metody zarządzające pamięcią (1178)
• Dostęp do łańcucha (1179)
• Proste przypisanie (1180)
• Przeszukiwanie łańcuchów (1180)
  • Rodzina funkcji find() (1180)
  • Rodzina funkcji rfind() (1181)
  • Rodzina funkcji find_first_of() (1182)
  • Rodzina funkcji find_last_of() (1182)
  • Rodzina funkcji find_first_not_of() (1183)
  • Rodzina funkcji find_last_not_of() (1183)
• Metody i funkcje porównania (1184)
• Modyfikatory łańcuchów (1185)
  • Metody dołączania i dodawania (1185)
  • Inne metody przypisania (1186)
  • Metody wstawiania (1187)
  • Metody usuwania (1188)
  • Metody zastępowania (1188)
  • Pozostałe metody modyfikujące: copy() oraz swap() (1189)
• Wejście i wyjście (1189)

Dodatek G Metody i funkcje z biblioteki STL (1191)

• Składowe wspólne dla wszystkich kontenerów (1191)
• Dodatkowe składowe wektorów, list i kolejek dwustronnych (1194)
• Dodatkowe składowe zbiorów i map (1197)
• Funkcje STL (1198)
  • Niemodyfikujące operacje sekwencyjne (1199)
  • Mutujące operacje sekwencyjne (1203)
  • Operacje sortowania i pokrewne (1211)
  • Operacje liczbowe (1224)

Dodatek H Wybrane pozycje książkowe i zasoby internetowe (1227)

• Wybrane pozycje książkowe (1227)
• Zasoby internetowe (1229)

Dodatek I Dostosowywanie do standardu ANSI/ISO C++ (1231)

• Stosuj rozwiązania alternatywne zamiast niektórych dyrektyw preprocesora (1231)
  • Do definiowania stałych używaj modyfikatora const zamiast dyrektywy #define (1231)
  • Do definiowania niewielkich funkcji używaj specyfikatora inline zamiast makrodefinicji #define (1233)
• Używaj prototypów funkcji (1234)
• Stosuj rzutowanie typów (1235)
• Poznaj i wykorzystuj mechanizmy języka C++ (1236)
• Używaj nowej organizacji plików nagłówkowych (1236)
• Korzystaj z przestrzeni nazw (1236)
• Używaj szablonu autoptr (1237)
• Używaj klasy string (1238)
• Korzystaj z biblioteki STL (1238)

Dodatek J Odpowiedzi do pytań kontrolnych (1241)