Wstęp

Rozdział 1. Pierwszy program w C++

• Dla kogo jest ta książka?    (13)
• Rys historyczny    (13)
• Dlaczego C++?    (14)
• C++ a C    (16)
• Aktualny standard języka    (16)
• Zanim napiszesz swój pierwszy program    (16)
• Środowisko programistyczne    (16)
• Pierwszy program    (18)
• Kompilacja kodu źródłowego    (18)
• Błędy kompilacji    (19)
• Uruchamianie programu w środowisku Dev-C++    (20)
• Struktura prostego programu w C++    (20)
• Obiekt std::cout i literały    (21)
• Definiowanie obiektów    (22)
• Identyfikatory, słowa kluczowe i dyrektywy    (24)
• Zapis programu    (24)
• Cztery działania matematyczne i typ double    (25)
• Jeszcze więcej matematyki    (26)
• Upraszczanie zapisu obiektów i funkcji biblioteki standardowej    (28)
• Źródła informacji    (28)
• Q & A    (29)
• Pytania przeglądowe    (30)
• Problemy    (30)

Rozdział 2. Wyrażenia i instrukcje

• Instrukcje sterujące    (31)
• Instrukcja if... else...    (31)
• Pętle    (33)
• Pętla for    (33)
• Pętle while i do    (35)
• Instrukcje break i continue    (35)
• Typy wbudowane    (36)
• Typy całkowite    (36)
• Typy zmiennopozycyjne    (38)
• Typ logiczny    (40)
• Zapis literałów całkowitych i zmiennopozycyjnych    (40)
• Wyrażenia arytmetyczne, promocje i konwersje standardowe    (41)
• Tworzenie obiektów stałych    (43)
• Modyfikator const    (43)
• Popularne typy standardowe    (44)
• Strumienie    (44)
• Napisy    (46)
• Wektory    (47)
• Słowniki    (49)
• Obiekty lokalne i globalne. Zasięg. Przesłanianie    (50)
• Operatory    (51)
• Priorytet operatorów    (53)
• Łączność operatorów    (53)
• Wartość operatorów    (53)
• Opis wybranych operatorów    (53)
• Operatorowe patologie    (57)
• Wyrażenia i instrukcje    (57)
• Q & A    (58)
• Pytania przeglądowe    (58)
• Problemy    (58)

Rozdział 3. Funkcje

• Referencje    (61)
• Funkcje swobodne    (62)
• Definiowanie funkcji    (62)
• Funkcje, które nie obliczają wartości    (63)
• Po co są funkcje?    (64)
• Funkcje składowe - wprowadzenie    (66)
• Argumenty funkcji    (66)
  • Przekazywanie argumentów przez wartość    (66)
  • Przekazywanie argumentów przez referencję    (67)
  • Przekazywanie argumentów przez stałą referencję    (67)
• Funkcje zwracające referencję    (69)
• Operatory jako funkcje swobodne    (70)
• Stos funkcji    (73)
• Funkcje otwarte (inline)    (75)
• Funkcje jako argumenty innych funkcji    (77)
• Rekurencja    (77)
• Argumenty domyślne    (78)
• Lokalne obiekty statyczne    (79)
• Funkcja main    (81)
• Argumenty funkcji main    (81)
• Wartość funkcji main    (81)
• Polimorfizm nazw funkcji    (82)
• Deklaracja a definicja funkcji    (82)
• Q & A    (83)
• Pytania przeglądowe    (83)
• Problemy    (83)

Rozdział 4. Tablice i wskaźniki

• Wskaźniki    (85)
• Definiowanie wskaźników    (85)
• Wskaźniki typu void*, czyli wycieczka w stronę C    (87)
• Wskaźnik zerowy    (87)
• Czym grozi nieumiejętne użycie wskaźników?    (87)
• Wskaźniki stałe i wskaźniki na stałe    (88)
• Wskaźniki na wskaźniki    (89)
• Tablice    (89)
• Tablice wielowymiarowe    (90)
• Inicjalizacja tablic    (91)
• Zastosowanie operatora sizeof do tablic    (91)
• Tablice a wskaźniki    (92)
• Tablice wskaźników i wskaźniki na tablice    (92)
• Tablice jako argumenty funkcji    (93)
• Teksty literalne i tablice znaków    (94)
• Porównanie tablic i wektorów    (95)
• Pamięć wolna (sterta)    (96)
• Q & A    (98)
• Pytania przeglądowe    (98)
• Problemy    (99)

Rozdział 5. Klasy i obiekty

• Struktury    (101)
• Podstawowe zasady definiowania i używania struktur    (101)
• Inicjalizacja struktur    (103)
• Dostęp do składowych poprzez wskaźnik    (103)
• Co to są klasy?    (104)
• Definiowanie klas    (104)
• Klasa jako ,,zmodyfikowana'' struktura    (104)
• Konstruktory    (104)
• Destruktor    (108)
• Funkcje składowe (metody)    (109)
• Metody i metody stałe    (110)
• Przeciążanie operatorów w klasie    (111)
• Konstruktor kopiujący i operator =    (111)
• Wskaźnik this    (114)
• Udostępnianie składowych    (115)
• Sekcje public i private    (115)
• Funkcje i klasy zaprzyjaźnione    (116)
• Interfejs i implementacja    (117)
• Podział definicji klasy na interfejs i implementację    (117)
• Kontrakty, niezmienniki i asercje    (120)
• Kontrakty    (120)
• Niezmienniki    (121)
• Hermetyzacja danych    (122)
• Różnice między klasami i strukturami    (122)
• Dygresja: składowe statyczne    (123)
• Pytania przeglądowe    (124)
• Problemy    (125)

Rozdział 6. Dynamiczne struktury danych

• Stos na bazie tablicy dynamicznej    (127)
• Interfejs stosu    (127)
• Implementacja stosu    (128)
• Test stosu    (133)
• Stos na bazie listy pojedynczo wiązanej    (134)
• Rekurencyjne struktury danych    (135)
• Interfejs klasy    (135)
• Implementacja    (136)
• Dygresja: przestrzenie nazw i zagnieżdżanie definicji klas    (137)
• Q & A    (139)
• Pytania przeglądowe    (139)
• Problemy    (140)

Rozdział 7. Dziedziczenie i polimorfizm

• Dziedziczenie    (141)
• Do czego służy dziedziczenie?    (141)
• Definiowanie klasy pochodnej    (143)
• Inicjalizacja klasy bazowej    (144)
• Relacje ,,X ma Y'', ,,X jest Y'' oraz ,,X zarządza Y''    (146)
• Kolejność inicjalizacji i destrukcji obiektu    (148)
• Sekcja protected    (148)
• Zastępowanie (overridnig) funkcji składowych    (149)
• Polimorfizm    (151)
• Niedoskonałości ,,zwykłego'' dziedziczenia    (151)
• Definiowanie metod polimorficznych    (153)
• vtable    (155)
• Dygresja: klasy abstrakcyjne    (155)
• Jak to się robi w Qt?    (157)
• Q & A    (161)
• Pytania przeglądowe    (161)
• Problemy    (162)

Rozdział 8. Strumienie

• Strumienie buforowane i niebuforowane    (163)
• Klawiatura, konsola, plik, strumień napisowy    (164)
• Stan strumienia    (166)
• Manipulatory i formatowanie strumienia    (167)
• Manipulator std::setw    (167)
• Manipulator std::setprecision    (168)
• Strumienie wyjścia    (169)
• Strumienie wejścia    (169)
• Funkcje składowe get i getline    (170)
• Inne funkcje operujące na strumieniach wejściowych    (170)
• Przykład    (171)
• Pytania przeglądowe    (173)
• Problemy    (174)

Rozdział 9. Biblioteki

• Podział programu na pliki    (175)
• Zasady kompilacji programów podzielonych na pliki    (176)
• Przygotowanie plików źródłowych i nagłówkowych    (177)
• Kompilacja za pomocą wiersza poleceń    (178)
• Kompilacja za pomocą programu make    (179)
• Kompilacja za pomocą projektów    (181)
• Automatyzacja tworzenia pliku Makefile    (183)
• Używanie gotowych bibliotek    (184)
• Dekorowanie nazw i deklaracja extern "C"    (184)
• Przykłady    (185)
• Kompilacja i instalacja programów lub bibliotek z plików źródłowych    (188)
• Przykłady    (188)
• Systemy kontroli wersji    (189)
• Pytania przeglądowe    (190)
• Problemy    (190)

Rozdział 10. Preprocesor i szablony

• Preprocesor    (191)
• Rola preprocesora w C++    (191)
• Dyrektywy preprocesora    (192)
• Przykład    (195)
• Podsumowanie    (197)
• Szablony    (197)
• Szablony klas    (197)
• Szablony funkcji składowych    (200)
• Szablony funkcji swobodnych    (201)
• Specjalizacja szablonu    (202)
• Używanie szablonów funkcji do upraszczania pracy z szablonami klas    (202)
• Gdzie umieszczać definicje szablonów?    (203)
• Szablony a programowanie generyczne    (204)
• Dygresja: konstrukcja typedef    (204)
• Pytania przeglądowe    (205)
• Problemy    (206)

Rozdział 11. Wprowadzenie do STL

• Co to jest STL?    (207)
• Pojemniki    (208)
• Iteratory    (208)
• Co to są iteratory?    (208)
• Przykład użycia iteratorów    (209)
• Rodzaje iteratorów    (210)
• Algorytmy    (211)
• Co to są algorytmy?    (211)
• Funktory    (212)
• Obiekty funkcyjne    (213)
• Wartości pobierane i zwracane przez algorytmy    (215)
• Obiekty funkcyjne a efektywność szablonów funkcji    (216)
• Wektory (std::vector)    (218)
• Opis szablonu std::vector    (218)
• Przykłady    (221)
• Liczby zespolone    (222)
• Napisy (std::string)    (223)
• Q & A    (224)
• Pytania przeglądowe    (225)
• Problemy    (225)

Rozdział 12. Pojemniki i algorytmy

• Przegląd pojemników STL    (227)
• Słowniki    (228)
• Zbiory    (232)
• Wielosłowniki i wielozbiory    (233)
• Słowniki i zbiory mieszające    (233)
• Kolejki o dwóch końcach    (235)
• Listy    (235)
• Stosy, kolejki i kolejki priorytetowe    (236)
• Wektory i zbiory bitów    (237)
• Wektory numeryczne (std::valarray)    (238)
• Przegląd algorytmów swobodnych    (239)
• Algorytmy niemodyfikujące    (240)
• Algorytmy modyfikujące    (241)
• Sortowanie    (245)
• Algorytmy numeryczne    (245)
• Inne algorytmy    (246)
• Przykład    (246)
• Kontrola poprawności użycia STL    (246)
• Składniki dodatkowe    (248)
• Q & A    (248)
• Pytania przeglądowe    (248)
• Problemy    (249)

Rozdział 13. Obsługa błędów

• Rodzaje błędów    (251)
• Analiza błędów składniowych: koncepty    (252)
• Wykrywanie błędów logicznych: debuger    (254)
• Debuger gdb    (255)
• Obsługa błędów czasu wykonania: wyjątki    (257)
• Zgłaszanie wyjątków    (259)
• Wyłapywanie wyjątków    (260)
• Wyjątki z metodami wirtualnymi    (261)
• Specyfikacja wyjątków    (262)
• Zwijanie stosu    (263)
• Wyjątki a gospodarka zasobami    (264)
• Przykład zastosowania wyjątków    (265)
• Q & A    (267)
• Pytania przeglądowe    (267)
• Problemy    (268)

Rozdział 14. Co dalej?

• Problemy    (272)

Dodatki

• Wybrane opcje kompilatora g++    (273)
• Dodatkowe elementy języka    (275)
• Instrukcja goto    (275)
• Instrukcja switch    (275)
• Zgodność języka C++ z językiem C    (276)
• Przyszłość języka C++    (277)
• Źródła informacji w internecie    (278)

Skorowidz

• Tytuł: Język C++. Pierwsze starcie
• Autor: Zbigniew Koza
• ISBN: 978-83-246-4507-7, 9788324645077
• Data wydania: 2012-01-18
• Format: Ebook
• Identyfikator pozycji: jcppps
• Wydawca: Helion