• Jak zacząć pracę w zintegrowanym środowisku programistycznym?
• Jak profesjonalnie tworzyć programy użytkowe?
• Jak korzystać z biblioteki graficznego interfejsu użytkownika?

Jeśli zależy Ci na tym, aby zdobyć rzetelną wiedzę i perfekcyjne umiejętności programowania z użyciem języka C++, powinieneś uczyć się od wybitnego eksperta i twórcy tego języka - Bjarne Stroustrupa, który jako pierwszy zaprojektował i zaimplementował C++. Podręcznik, który trzymasz w ręku, daje Ci szansę odkrycia wszelkich tajników tego języka, obszernie opisanego w międzynarodowym standardzie i obsługującego najważniejsze techniki programistyczne. C++ umożliwia pisanie wydajnego i eleganckiego kodu, a większość technik w nim stosowanych można przenieść do innych języków programowania.

Książka „Programowanie w C++. Teoria i praktyka” zawiera szczegółowy opis pojęć i technik programistycznych, a także samego języka C++, oraz przykłady kodu. Znajdziesz tu również omówienia zagadnień zaawansowanych, takich jak przetwarzanie tekstu i testowanie. Z tego podręcznika dowiesz się, na czym polega wywoływanie funkcji przeciążonych i dopasowywanie wyrażeń regularnych. Zobaczysz też, jaki powinien być standard kodowania. Poznasz sposoby projektowania klas graficznych i systemów wbudowanych, tajniki implementacji, wykorzystywania funkcji oraz indywidualizacji operacji wejścia i wyjścia. Korzystając z tego przewodnika, nauczysz się od samego mistrza pisać doskonałe, wydajne i łatwe w utrzymaniu programy.

• Techniki programistyczne
• Infrastruktura algorytmiczna
• Biblioteka standardowa C++
• Instrukcje sterujące i obsługa błędów
• Implementacja i wykorzystanie funkcji
• Kontrola typów
• Interfejsy klas
• Indywidualizacja operacji wejścia i wyjścia
• Projektowanie klas graficznych
• Wektory i pamięć wolna
• Kontenery i iteratory
• Programowanie systemów wbudowanych
• Makra

Dr Bjarne Stroustrup zaprojektował i jako pierwszy zaimplementował język C++. Stroustrup kieruje katedrą informatyki w College of Engineering na Uniwersytecie Texas A&M, jest członkiem amerykańskiej National Academy of Engineering oraz AT&T. Jest także założycielem i członkiem komisji standaryzacyjnej ISO w sprawach języka C++.

• Słowo do studentów (21)
• Słowo do nauczycieli (22)
• Pomoc (23)
• Podziękowania (23)

• 0.1. Struktura książki (26)
  • 0.1.1. Informacje ogólne (27)
  • 0.1.2. Ćwiczenia, praca domowa itp. (28)
  • 0.1.3. Po przeczytaniu tej książki (29)
• 0.2. Filozofia nauczania i uczenia się (29)
  • 0.2.1. Kolejność tematów (32)
  • 0.2.2. Programowanie a język programowania (34)
  • 0.2.3. Przenośność (34)
• 0.3. Programowanie a informatyka (35)
• 0.4. Kreatywność i rozwiązywanie problemów (35)
• 0.5. Uwagi dla autorów (35)
• 0.6. Bibliografia (36)
• 0.7. Noty biograficzne (37)
  • Bjarne Stroustrup (37)
  • Lawrence "Pete" Petersen (38)

• 1.1. Wstęp (40)
• 1.2. Oprogramowanie (40)
• 1.3. Ludzie (42)
• 1.4. Informatyka (45)
• 1.5. Komputery są wszędzie (46)
  • 1.5.1. Komputery z ekranem i bez (46)
  • 1.5.2. Transport (47)
  • 1.5.3. Telekomunikacja (48)
  • 1.5.4. Medycyna (50)
  • 1.5.5. Informacja (51)
  • 1.5.6. Sięgamy w kosmos (52)
  • 1.5.7. I co z tego (53)
• 1.6. Ideały dla programistów (54)

• 2.1. Programy (64)
• 2.2. Klasyczny pierwszy program (64)
• 2.3. Kompilacja (67)
• 2.4. Łączenie (69)
• 2.5. Środowiska programistyczne (70)

• 3.1. Dane wejściowe (78)
• 3.2. Zmienne (80)
• 3.3. Typy danych wejściowych (81)
• 3.4. Operacje i operatory (82)
• 3.5. Przypisanie i inicjacja (85)
  • 3.5.1. Przykład usuwania powtarzających się słów (87)
• 3.6. Złożone operatory przypisania (89)
  • 3.6.1. Przykład zliczania powtarzających się słów (89)
• 3.7. Nazwy (90)
• 3.8. Typy i obiekty (92)
• 3.9. Kontrola typów (94)
  • 3.9.1. Konwersje bezpieczne dla typów (95)
  • 3.9.2. Konwersje niebezpieczne dla typów (96)

• 4.1. Wykonywanie obliczeń (104)
• 4.2. Cele i narzędzia (105)
• 4.3. Wyrażenia (107)
  • 4.3.1. Wyrażenia stałe (108)
  • 4.3.2. Operatory (109)
  • 4.3.3. Konwersje (111)
• 4.4. Instrukcje (112)
  • 4.4.1. Selekcja (113)
  • 4.4.2. Iteracja (119)
• 4.5. Funkcje (122)
  • 4.5.1. Po co zaprzątać sobie głowę funkcjami (124)
  • 4.5.2. Deklarowanie funkcji (125)
• 4.6. Wektor (126)
  • 4.6.1. Powiększanie wektora (127)
  • 4.6.2. Przykład wczytywania liczb do programu (128)
  • 4.6.3. Przykład z użyciem tekstu (130)
• 4.7. Właściwości języka (132)

• 5.1. Wstęp (140)
• 5.2. Źródła błędów (141)
• 5.3. Błędy kompilacji (142)
  • 5.3.1. Błędy składni (142)
  • 5.3.2. Błędy typów (143)
  • 5.3.3. Nie błędy (144)
• 5.4. Błędy konsolidacji (145)
• 5.5. Błędy czasu wykonania (146)
  • 5.5.1. Rozwiązywanie problemu przez wywołującego (147)
  • 5.5.2. Rozwiązywanie problemu przez wywoływanego (148)
  • 5.5.3. Raportowanie błędów (149)
• 5.6. Wyjątki (151)
  • 5.6.1. Nieprawidłowe argumenty (151)
  • 5.6.2. Błędy zakresu (152)
  • 5.6.3. Nieprawidłowe dane wejściowe (154)
  • 5.6.4. Błędy zawężania zakresu (156)
• 5.7. Błędy logiczne (157)
• 5.8. Szacowanie (159)
• 5.9. Debugowanie (161)
  • 5.9.1. Praktyczna rada dotycząca debugowania (162)
• 5.10. Warunki wstępne i końcowe (165)
  • 5.10.1. Warunki końcowe (167)
• 5.11. Testowanie (168)

• 6.1. Problem (176)
• 6.2. Przemyślenie problemu (176)
  • 6.2.1. Etapy rozwoju oprogramowania (177)
  • 6.2.2. Strategia (177)
• 6.3. Wracając do kalkulatora (179)
  • 6.3.1. Pierwsza próba (180)
  • 6.3.2. Tokeny (182)
  • 6.3.3. Implementowanie tokenów (183)
  • 6.3.4. Używanie tokenów (185)
  • 6.3.5. Powrót do tablicy (187)
• 6.4. Gramatyki (188)
  • 6.4.1. Dygresja - gramatyka języka angielskiego (192)
  • 6.4.2. Pisanie gramatyki (193)
• 6.5. Zamiana gramatyki w kod (194)
  • 6.5.1. Implementowanie zasad gramatyki (194)
  • 6.5.2. Wyrażenia (195)
  • 6.5.3. Składniki (199)
  • 6.5.4. Podstawowe elementy wyrażeń (200)
• 6.6. Wypróbowywanie pierwszej wersji (201)
• 6.7. Wypróbowywanie drugiej wersji (205)
• 6.8. Strumienie tokenów (206)
  • 6.8.1. Implementacja typu Token_stream (207)
  • 6.8.2. Wczytywanie tokenów (209)
  • 6.8.3. Wczytywanie liczb (210)
• 6.9. Struktura programu (211)

• 7.1. Wprowadzenie (218)
• 7.2. Wejście i wyjście (218)
• 7.3. Obsługa błędów (220)
• 7.4. Liczby ujemne (224)
• 7.5. Reszta z dzielenia (225)
• 7.6. Oczyszczanie kodu (227)
  • 7.6.1. Stałe symboliczne (227)
  • 7.6.2. Użycie funkcji (229)
  • 7.6.3. Układ kodu (230)
  • 7.6.4. Komentarze (231)
• 7.7. Odzyskiwanie sprawności po wystąpieniu błędu (233)
• 7.8. Zmienne (236)
  • 7.8.1. Zmienne i definicje (236)
  • 7.8.2. Wprowadzanie nazw (240)
  • 7.8.3. Nazwy predefiniowane (242)
  • 7.8.4. Czy to już koniec? (243)

• 8.1. Szczegóły techniczne (248)
• 8.2. Deklaracje i definicje (249)
  • 8.2.1. Rodzaje deklaracji (252)
  • 8.2.2. Deklaracje stałych i zmiennych (252)
  • 8.2.3. Domyślna inicjacja (254)
• 8.3. Pliki nagłówkowe (254)
• 8.4. Zakres (256)
• 8.5. Wywoływanie i wartość zwrotna funkcji (261)
  • 8.5.1. Deklarowanie argumentów i typu zwrotnego (261)
  • 8.5.2. Zwracanie wartości (263)
  • 8.5.3. Przekazywanie przez wartość (264)
  • 8.5.4. Przekazywanie argumentów przez stałą referencję (265)
  • 8.5.5. Przekazywanie przez referencję (267)
  • 8.5.6. Przekazywanie przez wartość a przez referencję (269)
  • 8.5.7. Sprawdzanie argumentów i konwersja (271)
  • 8.5.8. Implementacja wywołań funkcji (272)
• 8.6. Porządek wykonywania instrukcji (276)
  • 8.6.1. Wartościowanie wyrażeń (277)
  • 8.6.2. Globalna inicjacja (277)
• 8.7. Przestrzenie nazw (279)
  • 8.7.1. Dyrektywy i deklaracje using (280)

• 9.1. Typy zdefiniowane przez użytkownika (288)
• 9.2. Klasy i składowe klas (289)
• 9.3. Interfejs i implementacja (289)
• 9.4. Tworzenie klas (291)
  • 9.4.1. Struktury i funkcje (291)
  • 9.4.2. Funkcje składowe i konstruktory (293)
  • 9.4.3. Ukrywanie szczegółów (294)
  • 9.4.4. Definiowanie funkcji składowych (296)
  • 9.4.5. Odwoływanie się do bieżącego obiektu (298)
  • 9.4.6. Raportowanie błędów (299)
• 9.5. Wyliczenia (300)
• 9.6. Przeciążanie operatorów (302)
• 9.7. Interfejsy klas (303)
  • 9.7.1. Typy argumentów (304)
  • 9.7.2. Kopiowanie (306)
  • 9.7.3. Konstruktory domyślne (306)
  • 9.7.4. Stałe funkcje składowe (309)
  • 9.7.5. Składowe i funkcje pomocnicze (310)
• 9.8. Klasa Date (312)

• 10.1. Wejście i wyjście (322)
• 10.2. Model strumieni wejścia i wyjścia (323)
• 10.3. Pliki (325)
• 10.4. Otwieranie pliku (326)
• 10.5. Odczytywanie i zapisywanie plików (328)
• 10.6. Obsługa błędów wejścia i wyjścia (330)
• 10.7. Wczytywanie pojedynczej wartości (332)
  • 10.7.1. Rozłożenie problemu na mniejsze części (334)
  • 10.7.2. Oddzielenie warstwy komunikacyjnej od funkcji (337)
• 10.8. Definiowanie operatorów wyjściowych (338)
• 10.9. Definiowanie operatorów wejściowych (339)
• 10.10. Standardowa pętla wejściowa (340)
• 10.11. Wczytywanie pliku strukturalnego (341)
  • 10.11.1. Reprezentacja danych w pamięci (342)
  • 10.11.2. Odczytywanie struktur wartości (343)
  • 10.11.3. Zmienianie reprezentacji (347)

• 11.1. Regularność i nieregularność (354)
• 11.2. Formatowanie danych wyjściowych (354)
  • 11.2.1. Wysyłanie na wyjście liczb całkowitych (355)
  • 11.2.2. Przyjmowanie na wejściu liczb całkowitych (356)
  • 11.2.3. Wysyłanie na wyjście liczb zmiennoprzecinkowych (357)
  • 11.2.4. Precyzja (358)
  • 11.2.5. Pola (360)
• 11.3. Otwieranie plików i pozycjonowanie (361)
  • 11.3.1. Tryby otwierania plików (361)
  • 11.3.2. Pliki binarne (362)
  • 11.3.3. Pozycjonowanie w plikach (365)
• 11.4. Strumienie łańcuchowe (365)
• 11.5. Wprowadzanie danych wierszami (367)
• 11.6. Klasyfikowanie znaków (368)
• 11.7. Stosowanie niestandardowych separatorów (370)
• 11.8. Zostało jeszcze tyle do poznania (376)

• 12.1. Czemu grafika? (382)
• 12.2. Model graficzny (383)
• 12.3. Pierwszy przykład (384)
• 12.4. Biblioteka GUI (387)
• 12.5. Współrzędne (388)
• 12.6. Figury geometryczne (388)
• 12.7. Używanie klas figur geometrycznych (389)
  • 12.7.1. Nagłówki graficzne i funkcja main (390)
  • 12.7.2. Prawie puste okno (390)
  • 12.7.3. Klasa Axis (392)
  • 12.7.4. Rysowanie wykresu funkcji (394)
  • 12.7.5. Wielokąty (394)
  • 12.7.6. Prostokąty (395)
  • 12.7.7. Wypełnianie kolorem (397)
  • 12.7.8. Tekst (398)
  • 12.7.9. Obrazy (399)
  • 12.7.10. Jeszcze więcej grafik (400)
• 12.8. Uruchamianie programu (401)
  • 12.8.1. Pliki źródłowe (402)

• 13.1. Przegląd klas graficznych (408)
• 13.2. Klasy Point i Line (410)
• 13.3. Klasa Lines (412)
• 13.4. Klasa Color (414)
• 13.5. Typ Line_style (416)
• 13.6. Typ Open_polyline (418)
• 13.7. Typ Closed_polyline (419)
• 13.8. Typ Polygon (420)
• 13.9. Typ Rectangle (422)
• 13.10. Wykorzystywanie obiektów bez nazw (426)
• 13.11. Typ Text (428)
• 13.12. Typ Circle (430)
• 13.13. Typ Ellipse (431)
• 13.14. Typ Marked_polyline (433)
• 13.15. Typ Marks (434)
• 13.16. Typ Mark (435)
• 13.17. Typ Image (436)

• 14.1. Zasady projektowania (444)
  • 14.1.1. Typy (444)
  • 14.1.2. Operacje (445)
  • 14.1.3. Nazewnictwo (446)
  • 14.1.4. Zmienność (448)
• 14.2. Klasa Shape (448)
  • 14.2.1. Klasa abstrakcyjna (450)
  • 14.2.2. Kontrola dostępu (451)
  • 14.2.3. Rysowanie figur (454)
  • 14.2.4. Kopiowanie i zmienność (456)
• 14.3. Klasy bazowe i pochodne (458)
  • 14.3.1. Układ obiektu (459)
  • 14.3.2. Tworzenie podklas i definiowanie funkcji wirtualnych (461)
  • 14.3.3. Przesłanianie (461)
  • 14.3.4. Dostęp (463)
  • 14.3.5. Czyste funkcje wirtualne (464)
• 14.4. Zalety programowania obiektowego (465)

• 15.1. Wprowadzenie (472)
• 15.2. Rysowanie wykresów prostych funkcji (472)
• 15.3. Typ Function (476)
  • 15.3.1. Argumenty domyślne (477)
  • 15.3.2. Więcej przykładów (478)
• 15.4. Typ Axis (479)
• 15.5. Wartość przybliżona funkcji wykładniczej (481)
• 15.6. Przedstawianie danych na wykresach (486)
  • 15.6.1. Odczyt danych z pliku (487)
  • 15.6.2. Układ ogólny (488)
  • 15.6.3. Skalowanie danych (489)
  • 15.6.4. Budowanie wykresu (490)

• 16.1. Różne rodzaje interfejsów użytkownika (498)
• 16.2. Przycisk Next (499)
• 16.3. Proste okno (500)
  • 16.3.1. Funkcje zwrotne (501)
  • 16.3.2. Pętla oczekująca (504)
• 16.4. Typ Button i inne pochodne typu Widget (505)
  • 16.4.1. Widgety (505)
  • 16.4.2. Przyciski (506)
  • 16.4.3. Widgety In_box i Out_box (507)
  • 16.4.4. Menu (507)
• 16.5. Przykład (508)
• 16.6. Inwersja kontroli (511)
• 16.7. Dodawanie menu (513)
• 16.8. Debugowanie kodu GUI (517)

• 17.1. Wprowadzenie (526)
• 17.2. Podstawowe wiadomości na temat typu vector (527)
• 17.3. Pamięć, adresy i wskaźniki (529)
  • 17.3.1. Operator sizeof (531)
• 17.4. Pamięć wolna a wskaźniki (532)
  • 17.4.1. Alokacja obiektów w pamięci wolnej (533)
  • 17.4.2. Dostęp poprzez wskaźniki (534)
  • 17.4.3. Zakresy (535)
  • 17.4.4. Inicjacja (536)
  • 17.4.5. Wskaźnik zerowy (537)
  • 17.4.6. Dealokacja pamięci wolnej (538)
• 17.5. Destruktory (540)
  • 17.5.1. Generowanie destruktorów (542)
  • 17.5.2. Destruktory a pamięć wolna (542)
• 17.6. Dostęp do elementów (544)
• 17.7. Wskaźniki na obiekty klas (545)
• 17.8. Babranie się w typach - void* i rzutowanie (546)
• 17.9. Wskaźniki i referencje (548)
  • 17.9.1. Wskaźniki i referencje jako parametry (549)
  • 17.9.2. Wskaźniki, referencje i dziedziczenie (550)
  • 17.9.3. Przykład - listy (551)
  • 17.9.4. Operacje na listach (552)
  • 17.9.5. Zastosowania list (554)
• 17.10. Wskaźnik this (555)
  • 17.10.1. Więcej przykładów użycia typu Link (557)

• 18.1. Wprowadzenie (564)
• 18.2. Kopiowanie (564)
  • 18.2.1. Konstruktory kopiujące (566)
  • 18.2.2. Przypisywanie z kopiowaniem (567)
  • 18.2.3. Terminologia związana z kopiowaniem (569)
• 18.3. Podstawowe operacje (570)
  • 18.3.1. Konstruktory jawne (571)
  • 18.3.2. Debugowanie konstruktorów i destruktorów (573)
• 18.4. Uzyskiwanie dostępu do elementów wektora (575)
  • 18.4.1. Problem stałych wektorów (576)
• 18.5. Tablice (577)
  • 18.5.1. Wskaźniki na elementy tablicy (578)
  • 18.5.2. Wskaźniki i tablice (580)
  • 18.5.3. Inicjowanie tablic (582)
  • 18.5.4. Problemy ze wskaźnikami (583)
• 18.6. Przykłady - palindrom (586)
  • 18.6.1. Wykorzystanie łańcuchów (586)
  • 18.6.2. Wykorzystanie tablic (587)
  • 18.6.3. Wykorzystanie wskaźników (588)

• 19.1. Analiza problemów (594)
• 19.2. Zmienianie rozmiaru (596)
  • 19.2.1. Reprezentacja (597)
  • 19.2.2. Rezerwacja pamięci i pojemność kontenera (598)
  • 19.2.3. Zmienianie rozmiaru (599)
  • 19.2.4. Funkcja push_back() (599)
  • 19.2.5. Przypisywanie (600)
  • 19.2.6. Podsumowanie dotychczasowej pracy nad typem vector (601)
• 19.3. Szablony (602)
  • 19.3.1. Typy jako parametry szablonów (603)
  • 19.3.2. Programowanie ogólne (605)
  • 19.3.3. Kontenery a dziedziczenie (607)
  • 19.3.4. Liczby całkowite jako parametry szablonów (608)
  • 19.3.5. Dedukcja argumentów szablonu (610)
  • 19.3.6. Uogólnianie wektora (610)
• 19.4. Sprawdzanie zakresu i wyjątki (613)
  • 19.4.1. Dygresja - uwagi projektowe (614)
  • 19.4.2. Wyznanie na temat makr (615)
• 19.5. Zasoby i wyjątki (617)
  • 19.5.1. Potencjalne problemy z zarządzaniem zasobami (617)
  • 19.5.2. Zajmowanie zasobów jest inicjacją (619)
  • 19.5.3. Gwarancje (620)
  • 19.5.4. Obiekt auto_ptr (621)
  • 19.5.5. Technika RAII dla wektora (622)

• 20.1. Przechowywanie i przetwarzanie danych (630)
  • 20.1.1. Praca na danych (630)
  • 20.1.2. Uogólnianie kodu (631)
• 20.2. Ideały twórcy biblioteki STL (634)
• 20.3. Sekwencje i iteratory (637)
  • 20.3.1. Powrót do przykładu (639)
• 20.4. Listy powiązane (641)
  • 20.4.1. Operacje list (642)
  • 20.4.2. Iteracja (643)
• 20.5. Jeszcze raz uogólnianie wektora (645)
• 20.6. Przykład - prosty edytor tekstu (647)
  • 20.6.1. Wiersze (649)
  • 20.6.2. Iteracja (650)
• 20.7. Typy vector, list oraz string (653)
  • 20.7.1. Funkcje insert() i erase() (654)
• 20.8. Dostosowanie wektora do biblioteki STL (656)
• 20.9. Dostosowywanie wbudowanych tablic do STL (658)
• 20.10. Przegląd kontenerów (660)
  • 20.10.1. Kategorie iteratorów (662)

• 21.1. Algorytmy biblioteki standardowej (668)
• 21.2. Najprostszy algorytm - find() (669)
  • 21.2.1. Kilka przykładów z programowania ogólnego (670)
• 21.3. Ogólny algorytm wyszukiwania - find_if() (671)
• 21.4. Obiekty funkcyjne (673)
  • 21.4.1. Abstrakcyjne spojrzenie na obiekty funkcyjne (674)
  • 21.4.2. Predykaty składowych klas (675)
• 21.5. Algorytmy numeryczne (676)
  • 21.5.1. Akumulacja (677)
  • 21.5.2. Uogólnianie funkcji accumulate() (678)
  • 21.5.3. Iloczyn skalarny (679)
  • 21.5.4. Uogólnianie funkcji inner_product() (681)
• 21.6. Kontenery asocjacyjne (681)
  • 21.6.1. Słowniki (682)
  • 21.6.2. Opis ogólny kontenera map (684)
  • 21.6.3. Jeszcze jeden przykład zastosowania słownika (687)
  • 21.6.4. Kontener unordered_map (689)
  • 21.6.5. Zbiory (691)
• 21.7. Kopiowanie (693)
  • 21.7.1. Funkcja copy() (693)
  • 21.7.2. Iteratory strumieni (694)
  • 21.7.3. Utrzymywanie porządku przy użyciu kontenera set (696)
  • 21.7.4. Funkcja copy_if() (696)
• 21.8. Sortowanie i wyszukiwanie (697)

• 22.1. Historia, ideały i profesjonalizm (706)
  • 22.1.1. Cele i filozofie języków programowania (706)
  • 22.1.2. Ideały programistyczne (708)
  • 22.1.3. Style i paradygmaty (714)
• 22.2. Krótka historia języków programowania (717)
  • 22.2.1. Pierwsze języki (718)
  • 22.2.2. Korzenie nowoczesnych języków programowania (719)
  • 22.2.3. Rodzina Algol (724)
  • 22.2.4. Simula (731)
  • 22.2.5. C (733)
  • 22.2.6. C++ (736)
  • 22.2.7. Dziś (738)
  • 22.2.8. Źródła informacji (740)

• 23.1. Tekst (746)
• 23.2. Łańcuchy (746)
• 23.3. Strumienie wejścia i wyjścia (750)
• 23.4. Słowniki (750)
  • 23.4.1. Szczegóły implementacyjne (755)
• 23.5. Problem (757)
• 23.6. Wyrażenia regularne (759)
• 23.7. Wyszukiwanie przy użyciu wyrażeń regularnych (761)
• 23.8. Składnia wyrażeń regularnych (764)
  • 23.8.1. Znaki i znaki specjalne (764)
  • 23.8.2. Rodzaje znaków (765)
  • 23.8.3. Powtórzenia (766)
  • 23.8.4. Grupowanie (767)
  • 23.8.5. Alternatywa (767)
  • 23.8.6. Zbiory i przedziały znaków (768)
  • 23.8.7. Błędy w wyrażeniach regularnych (769)
• 23.9. Dopasowywanie przy użyciu wyrażeń regularnych (770)
• 23.10. Źródła (775)

• 24.1. Wprowadzenie (780)
• 24.2. Rozmiar, precyzja i przekroczenie zakresu (780)
  • 24.2.1. Ograniczenia typów liczbowych (783)
• 24.3. Tablice (784)
• 24.4. Tablice wielowymiarowe w stylu języka C (785)
• 24.5. Biblioteka Matrix (786)
  • 24.5.1. Wymiary i dostęp (787)
  • 24.5.2. Macierze jednowymiarowe (789)
  • 24.5.3. Macierze dwuwymiarowe (792)
  • 24.5.4. Wejście i wyjście macierzy (794)
  • 24.5.5. Macierze trójwymiarowe (795)
• 24.6. Przykład - rozwiązywanie równań liniowych (796)
  • 24.6.1. Klasyczna eliminacja Gaussa (797)
  • 24.6.2. Wybór elementu centralnego (798)
  • 24.6.3. Testowanie (799)
• 24.7. Liczby losowe (800)
• 24.8. Standardowe funkcje matematyczne (802)
• 24.9. Liczby zespolone (803)
• 24.10. Źródła (804)

• 25.1. Systemy wbudowane (810)
• 25.2. Podstawy (813)
  • 25.2.1. Przewidywalność (815)
  • 25.2.2. Ideały (815)
  • 25.2.3. Życie z awarią (816)
• 25.3. Zarządzanie pamięcią (818)
  • 25.3.1. Problemy z pamięcią wolną (819)
  • 25.3.2. Alternatywy dla ogólnej pamięci wolnej (822)
  • 25.3.3. Przykład zastosowania puli (823)
  • 25.3.4. Przykład użycia stosu (824)
• 25.4. Adresy, wskaźniki i tablice (825)
  • 25.4.1. Niekontrolowane konwersje (825)
  • 25.4.2. Problem - źle działające interfejsy (826)
  • 25.4.3. Rozwiązanie - klasa interfejsu (829)
  • 25.4.4. Dziedziczenie a kontenery (832)
• 25.5. Bity, bajty i słowa (834)
  • 25.5.1. Bity i operacje na bitach (835)
  • 25.5.2. Klasa bitset (839)
  • 25.5.3. Liczby ze znakiem i bez znaku (840)
  • 25.5.4. Manipulowanie bitami (844)
  • 25.5.5. Pola bitowe (846)
  • 25.5.6. Przykład - proste szyfrowanie (847)
• 25.6. Standardy pisania kodu (851)
  • 25.6.1. Jaki powinien być standard kodowania (852)
  • 25.6.2. Przykładowe zasady (854)
  • 25.6.3. Prawdziwe standardy kodowania (859)

• 26.1. Czego chcemy (866)
  • 26.1.1. Zastrzeżenie (867)
• 26.2. Dowody (867)
• 26.3. Testowanie (867)
  • 26.3.1. Testowanie regresyjne (868)
  • 26.3.2. Testowanie jednostkowe (869)
  • 26.3.3. Algorytmy i nie-algorytmy (875)
  • 26.3.4. Testy systemowe (882)
  • 26.3.5. Testowanie klas (886)
  • 26.3.6. Znajdowanie założeń, które się nie potwierdzają (889)
• 26.4. Projektowanie pod kątem testowania (890)
• 26.5. Debugowanie (891)
• 26.6. Wydajność (891)
  • 26.6.1. Kontrolowanie czasu (893)
• 26.7. Źródła (895)

• 27.1. C i C++ to rodzeństwo (900)
  • 27.1.1. Zgodność języków C i C++ (901)
  • 27.1.2. Co jest w języku C++, czego nie ma w C (903)
  • 27.1.3. Biblioteka standardowa języka C (904)
• 27.2. Funkcje (905)
  • 27.2.1. Brak możliwości przeciążania nazw funkcji (906)
  • 27.2.2. Sprawdzanie typów argumentów funkcji (906)
  • 27.2.3. Definicje funkcji (907)
  • 27.2.4. Wywoływanie C z poziomu C++ i C++ z poziomu C (909)
  • 27.2.5. Wskaźniki na funkcje (911)
• 27.3. Mniej ważne różnice między językami (912)
  • 27.3.1. Przestrzeń znaczników struktur (912)
  • 27.3.2. Słowa kluczowe (913)
  • 27.3.3. Definicje (914)
  • 27.3.4. Rzutowanie w stylu języka C (915)
  • 27.3.5. Konwersja typu void* (916)
  • 27.3.6. Typ enum (917)
  • 27.3.7. Przestrzenie nazw (917)
• 27.4. Pamięć wolna (918)
• 27.5. Łańcuchy w stylu języka C (919)
  • 27.5.1. Łańcuchy w stylu języka C i const (922)
  • 27.5.2. Operacje na bajtach (922)
  • 27.5.3. Przykład - funkcja strcpy() (923)
  • 27.5.4. Kwestia stylu (923)
• 27.6. Wejście i wyjście - nagłówek stdio (924)
  • 27.6.1. Wyjście (924)
  • 27.6.2. Wejście (925)
  • 27.6.3. Pliki (927)
• 27.7. Stałe i makra (927)
• 27.8. Makra (928)
  • 27.8.1. Makra podobne do funkcji (929)
  • 27.8.2. Makra składniowe (930)
  • 27.8.3. Kompilacja warunkowa (931)
• 27.9. Przykład - kontenery intruzyjne (932)

• A.1. Opis ogólny (944)
• A.2. Literały (946)
• A.3. Identyfikatory (950)
• A.4. Zakres, pamięć oraz czas trwania (950)
• A.5. Wyrażenia (953)
• A.6. Instrukcje (962)
• A.7. Deklaracje (964)
• A.8. Typy wbudowane (965)
• A.9. Funkcje (968)
• A.10. Typy zdefiniowane przez użytkownika (971)
• A.11. Wyliczenia (972)
• A.12. Klasy (972)
• A.13. Szablony (983)
• A.14. Wyjątki (986)
• A.15. Przestrzenie nazw (988)
• A.16. Aliasy (988)
• A.17. Dyrektywy preprocesora (989)

• B.1. Przegląd (992)
• B.2. Obsługa błędów (995)
• B.3. Iteratory (997)
• B.4. Kontenery (1001)
• B.5. Algorytmy (1008)
• B.6. Biblioteka STL (1016)
• B.7. Strumienie wejścia i wyjścia (1018)
• B.8. Przetwarzanie łańcuchów (1024)
• B.9. Obliczenia (1028)
• B.10. Funkcje biblioteki standardowej C (1032)
• B.11. Inne biblioteki (1040)

• C.1. Uruchamianie programu (1044)
• C.2. Instalowanie środowiska Visual Studio (1044)
• C.3. Tworzenie i uruchamianie programu (1044)
• C.4. Później (1046)

• D.1. Wprowadzenie (1048)
• D.2. Pobieranie biblioteki FLTK z internetu (1048)
• D.3. Instalowanie biblioteki FLTK (1048)
• D.4. Korzystanie z biblioteki FLTK w Visual Studio (1049)
• D.5. Sprawdzanie, czy wszystko działa (1050)

• E.1. Implementacja wywołań zwrotnych (1052)
• E.2. Implementacja klasy Widget (1053)
• E.3. Implementacja klasy Window (1054)
• E.4. Klasa Vector_ref (1055)
• E.5. Przykład - widgety (1056)