.:$$:.

Materiał zawarty w tej książce to podstawowe zagadnienia i koncepcje związane z programowaniem w C++, tak więc nie musisz posiadać żadnego doświadczenia w programowaniu w tym języku. Liczne przykłady składni oraz szczegółowa analiza kodu stanowią doskonały przewodnik na początku podróży, której celem jest opanowanie programowania w języku C++. Bez względu na to, czy jesteś początkujący, czy też posiadasz pewne doświadczenie w programowaniu, przekonasz się, że dzięki przejrzystej organizacji tej książki nauka C++ będzie szybka i łatwa.

Książka ta stanowi wprowadzenie do programowania w języku C++. Nie koncentruje się na konkretnej implementacji, lecz raczej opisuje standard ANSI/ISO; znajdziesz w niej również omówienie biblioteki STL (Standard Template Library). Jeśli nawet nie masz doświadczenia w pisaniu programów, to dzięki tej książce:

• Będziesz tworzył szybkie i wydajne programy w C++.
• Zrozumiesz standard ANSI/ISO i skorzystasz z wprowadzonych w nim zmian.
• Opanujesz zaawansowane programowanie z użyciem funkcji, tablic, zmiennych i wskaźników.
• Poznasz C++ oraz obiektowo zorientowane projektowanie, programowanie i analizę.
• Nauczysz się wzbogacać swoje programy za pomocą dziedziczenia i polimorfizmu.
• Będziesz mógł korzystać z dowolnego kompilatora zgodnego ze standardem ANSI/ISO C++.

O Autorze (15)
Wstęp (17)
Część I (19)
Rozdział 1. Zaczynamy (21)

• Wprowadzenie (21)
• Krótka historia języka C++ (21)
• Rozwiązywanie problemów (22)
• Programowanie proceduralne, strukturalne i obiektowe (23)
• C++ i programowanie zorientowane obiektowo (25)
• Jak ewoluowało C++ (26)
• Czy należy najpierw poznać C? (26)
• C++ a Java i C# (27)
• Standard ANSI (27)
• Przygotowanie do programowania (28)
• Twoje środowisko programowania (28)
• Tworzenie programu (29)
• Tworzenie pliku obiektowego za pomocą kompilatora (29)
• Tworzenie pliku wykonywalnego za pomocą linkera (30)
• Cykl tworzenia programu (30)
• HELLO.cpp - twój pierwszy program w C++ (32)
• Zaczynamy pracę z kompilatorem (34)
• Budowanie projektu Hello World (34)
• Błędy kompilacji (36)

Rozdział 2. Anatomia programu C++ (37)

• Prosty program (37)
• Rzut oka na obiekt cout (39)
• Używanie przestrzeni nazw standardowych (41)
• Komentarze (43)
• Rodzaje komentarzy (44)
• Używanie komentarzy (44)
• Jeszcze jedna uwaga na temat komentarzy (45)
• Funkcje (45)
• Korzystanie z funkcji (46)

Rozdział 3. Zmienne i stałe (49)

• Czym jest zmienna? (49)
• Dane są przechowywane w pamięci (49)
• Przydzielanie pamięci (50)
• Rozmiar liczb całkowitych (51)
• Zapis ze znakiem i bez znaku (52)
• Podstawowe typy zmiennych (53)
• Definiowanie zmiennej (54)
• Uwzględnianie wielkości liter (55)
• Słowa kluczowe (56)
• Tworzenie kilku zmienych jednocześnie (56)
• Przypisywanie zmiennym wartości (56)
• typedef (58)
• Kiedy używać typu short, a kiedy typu long? (59)
• Zawinięcie liczby całkowitej bez znaku (60)
• Zawinięcie liczby całkowitej ze znakiem (61)
• Znaki (62)
• Znaki i liczby (62)
• Znaki specjalne (63)
• Stałe (64)
• Literały (64)
• Stałe symboliczne (64)
• Stałe wyliczeniowe (66)

Rozdział 4. Wyrażenia i instrukcje (69)

• Instrukcje (69)
• Białe spacje (70)
• Bloki i instrukcje złożone (70)
• Wyrażenia (70)
• Operatory (72)
• Operator przypisania (72)
• Operatory matematyczne (73)
• Dzielenie całkowite i reszta z dzielenia (73)
• Łączenie operatora przypisania z operatorem matematycznym (74)
• Inkrementacja i dekrementacja (75)
• Przedrostki i przyrostki (75)
• Kolejność działań (77)
• Zagnieżdżanie nawiasów (78)
• Prawda i fałsz (79)
• Operatory relacji (79)
• Instrukcja if (80)
• Styl wcięć (83)
• else (84)
• Zaawansowane instrukcje if (86)
• Użycie nawiasów klamrowych w zagnieżdżonych instrukcjach if (87)
• Operatory logiczne (89)
• Logiczne I (90)
• Logiczne LUB (90)
• Logiczne NIE (90)
• Skrócone obliczanie wyrażeń logicznych (91)
• Kolejność operatorów logicznych (91)
• Kilka słów na temat prawdy i fałszu (92)
• Operator warunkowy (trójelementowy) (93)

Rozdział 5. Funkcje (95)

• Czym jest funkcja? (95)
• Zwracane wartości, parametry i argumenty (96)
• Deklarowanie i definiowanie funkcji (97)
• Deklarowanie funkcji (97)
• Prototypy funkcji (98)
• Definiowanie funkcji (99)
• Wykonywanie funkcji (100)
• Zmienne lokalne (101)
• Zakres (102)
• Zmienne globalne (102)
• Zmienne globalne: ostrzeżenie (104)
• Kilka słów na temat zmiennych lokalnych (104)
• Instrukcje funkcji (106)
• Kilka słów na temat argumentów funkcji (106)
• Użycie funkcji jako parametrów funkcji (106)
• Parametry są zmiennymi lokalnymi (107)
• Kilka słów na temat zwracanych wartości (109)
• Parametry domyślne (111)
• Przeciążanie funkcji (113)
• Zagadnienia związane z funkcjami (116)
• Funkcje typu inline (116)
• Rekurencja (118)
• Jak działają funkcje - rzut oka "pod maskę" (123)
• Poziomy abstrakcji (123)
• Podział pamięci (123)
• Stos i funkcje (126)

Rozdział 6. Programowanie zorientowane obiektowo (129)

• Czy C++ jest zorientowane obiektowo? (129)
• Tworzenie nowych typów (130)
• Po co tworzyć nowy typ? (131)
• Klasy i składowe (131)
• Deklarowanie klasy (132)
• Kilka słów o konwencji nazw (132)
• Definiowanie obiektu (133)
• Klasy a obiekty (133)
• Dostęp do składowych klasy (134)
• Przypisywać należy obiektom, nie klasom (134)
• Czego nie zadeklarujesz, tego klasa nie będzie miała (134)
• Prywatne i publiczne (135)
• Oznaczanie danych składowych jako prywatnych (137)
• Prywatność a ochrona (138)
• Implementowanie metod klasy (140)
• Konstruktory i destruktory (142)
• Domyślne konstruktory i destruktory (143)
• Użycie domyślnego konstruktora (143)
• Funkcje składowe const (146)
• Interfejs a implementacja (147)
• Gdzie umieszczać deklaracje klasy i definicje metod (150)
• Implementacja inline (151)
• Klasy, których danymi składowymi są inne klasy (153)
• Struktury (157)
• Dlaczego dwa słowa kluczowe spełniają tę samą funkcję (157)

Rozdział 7. Sterowanie przebiegiem działania programu (159)

• Pętle (159)
• Początki pętli: instrukcja goto (159)
• Dlaczego nie jest zalecane stosowanie instrukcji goto? (160)
• Pętle while (160)
• Bardziej skomplikowane instrukcje while (162)
• continue oraz break (163)
• Pętla while (true) (166)
• Pętla do...while (167)
• do...while (168)
• Pętle for (170)
• Zaawansowane pętle for (171)
• Puste pętle for (174)
• Pętle zagnieżdżone (175)
• Zakres zmiennych w pętlach for (177)
• Podsumowanie pętli (178)
• Instrukcja switch (180)
• Użycie instrukcji switch w menu (182)
• Program podsumowujący wiadomości (186)

Część II (191)
Rozdział 8. Wskaźniki (193)

• Czym jest wskaźnik? (193)
• Kilka słów na temat pamięci (193)
• Użycie operatora adresu (&) (194)
• Przechowywanie adresu we wskaźniku (195)
• Puste i błędne wskaźniki (195)
• Nazwy wskaźników (196)
• Operator wyłuskania (197)
• Wskaźniki, adresy i zmienne (197)
• Operowanie danymi poprzez wskaźniki (199)
• Sprawdzanie adresu (200)
• Do czego służą wskaźniki? (202)
• Stos i sterta (203)
• Operator new (204)
• delete (204)
• Wycieki pamięci (206)
• Tworzenie obiektów na stercie (207)
• Usuwanie obiektów (207)
• Dostęp do składowych klasy (208)
• Dane składowe na stercie (210)
• Wskaźnik this (212)
• Utracone wskaźniki (214)
• Wskaźniki const (217)
• Wskaźniki const i funkcje składowe const (218)
• Wskaźniki const this (219)
• Działania arytmetyczne na wskaźnikach - temat dla zaawansowanych (220)

Rozdział 9. Referencje (223)

• Czym jest referencja? (223)
• Użycie operatora adresu z referencją (225)
• Nie można zmieniać przypisania referencji (226)
• Do czego mogą odnosić się referencje? (227)
• Zerowe wskaźniki i zerowe referencje (229)
• Przekazywanie argumentów funkcji przez referencję (229)
• Tworzenie funkcji swap() otrzymującej wskaźniki (231)
• Implementacja funkcji swap() za pomocą referencji (233)
• Nagłówki i prototypy funkcji (234)
• Zwracanie kilku wartości (235)
• Zwracanie wartości przez referencję (237)
• Przekazywanie przez referencję zwiększa efektywność działania programu (238)
• Przekazywanie wskaźnika const (241)
• Referencje jako metoda alternatywna (243)
• Kiedy używać wskaźników, a kiedy referencji (245)
• Łączenie referencji i wskaźników (246)
• Nie pozwól funkcji zwracać referencji do obiektu, którego nie ma w zakresie! (247)
• Zwracanie referencji do obiektu na stercie (249)
• Wskaźnik, wskaźnik, kto ma wskaźnik? (251)

Rozdział 10. Funkcje zaawansowane (253)

• Przeciążone funkcje składowe (253)
• Użycie wartości domyślnych (255)
• Wybór pomiędzy wartościami domyślnymi a przeciążaniem funkcji (257)
• Konstruktor domyślny (258)
• Przeciążanie konstruktorów (258)
• Inicjalizowanie obiektów (260)
• Konstruktor kopiujący (261)
• Przeciążanie operatorów (265)
• Pisanie funkcji inkrementacji (266)
• Przeciążanie operatora przedrostkowego (267)
• Zwracanie typów w przeciążonych funkcjach operatorów (268)
• Zwracanie obiektów tymczasowych bez nadawania im nazw (270)
• Użycie wskaźnika this (271)
• Dlaczego stała referencja? (273)
• Przeciążanie operatora przyrostkowego (273)
• Różnica pomiędzy przedrostkiem a przyrostkiem (273)
• Operator dodawania (275)
• Przeciążanie operatora dodawania (277)
• Zagadnienia związane z przeciążaniem operatorów (278)
• Ograniczenia w przeciążaniu operatorów (278)
• Co przeciążać? (279)
• Operator przypisania (279)
• Obsługa konwersji typów danych (282)
• Operatory konwersji (285)

Rozdział 11. Analiza i projektowanie zorientowane obiektowo (287)

• Budowanie modeli (287)
• Projektowanie oprogramowania: język modelowania (288)
• Projektowanie oprogramowania: proces (289)
• Programowanie ekstremalne (292)
• Pomysł (292)
• Analiza wymagań (293)
• Przypadki użycia (293)
• Analiza aplikacji (303)
• Analiza systemów (304)
• Tworzenie dokumentacji (304)
• Wizualizacje (305)
• Dokumentacja produktu (305)
• Projektowanie (306)
• Czym są klasy? (306)
• Przekształcenia (308)
• Model statyczny (309)
• Model dynamiczny (318)

Rozdział 12. Dziedziczenie (321)

• Czym jest dziedziczenie? (321)
• Dziedziczenie i wyprowadzanie (322)
• Królestwo zwierząt (323)
• Składnia wyprowadzania (323)
• Prywatne kontra chronione (325)
• Konstruktory i destruktory (327)
• Przekazywanie argumentów do konstruktorów bazowych (329)
• Przesłanianie funkcji (333)
• Ukrywanie metod klasy bazowej (335)
• Wywoływanie metod klasy bazowej (337)
• Metody wirtualne (338)
• Jak działają funkcje wirtualne (342)
• Nie możesz przejść stąd dotąd (343)
• Okrajanie (344)
• Destruktory wirtualne (346)
• Wirtualne konstruktory kopiujące (346)
• Koszt metod wirtualnych (349)

Rozdział 13. Tablice i listy połączone (351)

• Czym jest tablica? (351)
• Elementy tablicy (352)
• Zapisywanie za końcem tablicy (353)
• Błąd słupka w płocie (356)
• Inicjalizowanie tablic (356)
• Deklarowanie tablic (357)
• Tablice obiektów (358)
• Tablice wielowymiarowe (360)
• Inicjalizowanie tablic wielowymiarowych (360)
• Kilka słów na temat pamięci (362)
• Tablice wskaźników (363)
• Deklarowane tablic na stercie (364)
• Wskaźnik do tablicy a tablica wskaźników (365)
• Wskaźniki a nazwy tablic (365)
• Usuwanie tablic ze sterty (367)
• Tablice znaków (368)
• strcpy() oraz strncpy() (370)
• Klasy łańcuchów (371)
• Listy połączone i inne struktury (378)
• Analiza listy połączonej (378)
• Przeniesienie odpowiedzialności (379)
• Części składowe (379)
• Czego się nauczyłaś, Dorotko? (388)
• Klasy tablic (388)

Rozdział 14. Polimorfizm (391)

• Problemy z pojedynczym dziedziczeniem (391)
• Przenoszenie w górę (394)
• Rzutowanie w dół (394)
• Połączenie dwóch list (397)
• Dziedziczenie wielokrotne (397)
• Części obiektu z dziedziczeniem wielokrotnym (400)
• Konstruktory w obiektach dziedziczonych wielokrotnie (401)
• Eliminowanie niejednoznaczności (403)
• Dziedziczenie ze wspólnej klasy bazowej (404)
• Dziedziczenie wirtualne (408)
• Problemy z dziedziczeniem wielokrotnym (411)
• Mixiny i klasy metod (412)
• Abstrakcyjne typy danych (413)
• Czyste funkcje wirtualne (416)
• Implementowanie czystych funkcji wirtualnych (417)
• Złożone hierarchie abstrakcji (420)
• Które typy są abstrakcyjne? (424)
• Program podsumowujący wiadomości (425)

Część III (435)
Rozdział 15. Specjalne klasy i funkcje (437)

• Statyczne dane składowe (437)
• Statyczne funkcje składowe (442)
• Wskaźniki do funkcji (444)
• Dlaczego warto używać wskaźników do funkcji? (447)
• Tablice wskaźników do funkcji (450)
• Przekazywanie wskaźników do funkcji innym funkcjom (452)
• Użycie instrukcji typedef ze wskaźnikami do funkcji (455)
• Wskaźniki do funkcji składowych (457)
• Tablice wskaźników do funkcji składowych (459)

Rozdział 16. Dziedziczenie zaawansowane (463)

• Zawieranie (463)
• Dostęp do składowych klasy zawieranej (469)
• Filtrowany dostęp do składowych zawieranych (469)
• Koszt zawierania (470)
• Kopiowanie przez wartość (473)
• Implementowanie poprzez dziedziczenie i zawieranie oraz poprzez delegację (476)
• Delegacja (477)
• Dziedziczenie prywatne (485)
• Klasy zaprzyjaźnione (493)
• Funkcje zaprzyjaźnione (501)
• Funkcje zaprzyjaźnione i przeciążanie operatorów (501)
• Przeciążanie operatora wstawiania (505)

Rozdział 17. Strumienie (511)

• Przegląd strumieni (511)
• Kapsułkowanie (512)
• Buforowanie (512)
• Strumienie i bufory (514)
• Standardowe obiekty wejścia-wyjścia (514)
• Przekierowywanie (515)
• Wejście z użyciem cin (516)
• Łańcuchy (517)
• Problemy z łańcuchami (517)
• Zwracanie referencji do obiektu istream przez operator>> (520)
• Inne funkcje składowe w dyspozycji cin (520)
• Wprowadzanie pojedynczych znaków (521)
• Odczytywanie łańcuchów z wejścia standardowego (523)
• Użycie cin.ignore() (526)
• peek() oraz putback() (527)
• Wyjście poprzez cout (528)
• Zrzucanie zawartości bufora (528)
• Powiązane funkcje (528)
• Manipulatory, znaczniki oraz instrukcje formatowania (530)
• Użycie cout.width() (530)
• Ustawianie znaków wypełnienia (531)
• Funkcja setf() (532)
• Strumienie kontra funkcja printf() (534)
• Wejście i wyjście z użyciem plików (537)
• ofstream (538)
• Stany strumieni (538)
• Otwieranie plików dla wejścia i wyjścia (538)
• Zmiana domyślnego zachowania obiektu ofstream w trakcie otwierania pliku (540)
• Pliki binarne a pliki tekstowe (542)
• Przetwarzanie linii polecenia (544)

Rozdział 18. Przestrzenie nazw (549)

• Zaczynamy (549)
• Funkcje i klasy są rozpoznawane poprzez nazwy (550)
• Tworzenie przestrzeni nazw (553)
• Deklarowanie i definiowanie typów (554)
• Definiowanie funkcji poza przestrzenią nazw (554)
• Dodawanie nowych składowych (555)
• Zagnieżdżanie przestrzeni nazw (555)
• Używanie przestrzeni nazw (556)
• Słowo kluczowe using (558)
• Dyrektywa using (558)
• Deklaracja using (559)
• Alias przestrzeni nazw (561)
• Nienazwana przestrzeń nazw (561)
• Standardowa przestrzeń nazw std (562)

Rozdział 19. Wzorce (565)

• Czym są wzorce? (565)
• Typy parametryzowane (566)
• Tworzenie egzemplarza wzorca (566)
• Definicja wzorca (566)
• Użycie nazwy (568)
• Implementowanie wzorca (568)
• Funkcje wzorcowe (571)
• Wzorce i przyjaciele (572)
• Niewzorcowe zaprzyjaźnione klasy i funkcje (572)
• Ogólne wzorcowe zaprzyjaźnione klasy i funkcje (575)
• Użycie elementów wzorca (579)
• Funkcje specjalizowane (582)
• Wzorce i składowe statyczne (588)
• Standardowa biblioteka wzorców (591)
• Kontenery (591)
• Kontenery sekwencyjne (592)
• Kontener vector (592)
• Kontener list (598)
• Kontener deque (599)
• Stosy (600)
• Kolejki (601)
• Kontenery asocjacyjne (601)
• Kontener map (601)
• Inne kontenery asocjacyjne (604)
• Klasy algorytmów (604)
• Bezmutacyjne operacje sekwencyjne (605)
• Mutacyjne algorytmy sekwencyjne (606)

Rozdział 20. Wyjątki i obsługa błędów (609)

• Pluskwy, błędy, pomyłki i "psujący" się kod (609)
• Wyjątki (610)
• Wyjątki (611)
• Jak używane są wyjątki (611)
• Użycie bloków try oraz bloków catch (616)
• Wychwytywanie wyjątków (616)
• Wychwytywanie więcej niż jednego rodzaju wyjątków (617)
• Hierarchie wyjątków (620)
• Dane w wyjątkach oraz nazwane obiekty wyjątków (622)
• Wyjątki i wzorce (629)
• Wyjątki bez błędów (631)
• Kilka słów na temat "psującego" się kodu (632)
• Pluskwy i odpluskwianie (633)
• Punkty wstrzymania (633)
• Śledzenie wartości zmiennych (633)
• Sprawdzanie pamięci (634)
• Asembler (634)

Rozdział 21. Co dalej (635)

• Preprocesor i kompilator (635)
• Przeglądanie formy pośredniej (636)
• Użycie dyrektywy #define (636)
• Użycie #define dla stałych (636)
• Użycie #define do definiowania symboli (636)
• Dyrektywa #else preprocesora (637)
• Dołączanie i wartowniki dołączania (638)
• Funkcje makro (640)
• Po co te wszystkie nawiasy? (641)
• Makra a funkcje i wzorce (642)
• Funkcje inline (642)
• Manipulacje łańcuchami (644)
• Zamiana w łańcuch (644)
• Konkatenacja (644)
• Makra predefiniowane (645)
• Makro assert() (645)
• Debuggowanie za pomocą makra assert() (647)
• Makro assert() a wyjątki (647)
• Efekty uboczne (648)
• Niezmienniki klas (648)
• Wypisywanie wartości tymczasowych (653)
• Poziomy debuggowania (654)
• Operacje na bitach (660)
• Operator AND (661)
• Operator OR (661)
• Operator XOR (661)
• Operator negacji (661)
• Ustawianie bitów (661)
• Zerowanie bitów (662)
• Zmiana stanu bitów na przeciwny (662)
• Pola bitowe (663)
• Styl (666)
• Wcięcia (666)
• Nawiasy klamrowe (666)
• Długość linii (666)
• Instrukcje switch (667)
• Tekst programu (667)
• Nazwy identyfikatorów (668)
• Komentarze (669)
• Dostęp (670)
• Definicje klas (670)
• Dołączanie plików (670)
• assert() (671)
• const (671)
• Następne kroki (671)
• Gdzie uzyskać pomoc i poradę (671)
• Przejść do C#? (672)
• Bądź w kontakcie (672)
• Program podsumowujący wiadomości (672)

Dodatki (683)
Dodatek A Dwójkowo i szesnastkowo (685)

• Inne podstawy (686)
• Wokół podstaw (686)
• Dwójkowo (688)
• Dlaczego podstawa 2? (689)
• Bity, bajty, nible (689)
• Co to jest KB? (690)
• Liczby dwójkowe (690)
• Szesnastkowo (691)

Dodatek B Słowa kluczowe C++ (695)
Dodatek C Kolejność operatorów (697)
Skorowidz (699)