C++. Przewodnik dla początkujących - Alex Allain

Spis treści

CZĘŚĆ I. WSKOCZ W C++ (13)

Rozdział 1. Wprowadzenie. Konfiguracja środowiska programistycznego (15)

• Czym jest język programowania? (15)
• Słyszałem o języku, który nazywa się C. Jaka jest różnica między nim a C++? (15)
• Czy powinienem znać C, aby nauczyć się C++? (16)
• Czy żeby zostać programistą, muszę znać matematykę? (16)
• Terminologia (16)
  
  • Programowanie (16)
  • Plik wykonywalny (16)
• Edycja i kompilowanie plików źródłowych (17)
• Uwaga na temat przykładowych kodów źródłowych (17)
• Windows (17)
  
  • Krok 1. Pobierz Code::Blocks (18)
  • Krok 2. Zainstaluj Code::Blocks (18)
  • Krok 3. Uruchom Code::Blocks (18)
  • Rozwiązywanie problemów (21)
  • Czym właściwie jest Code::Blocks? (23)
• Macintosh (23)
  
  • Xcode (23)
  • Instalowanie Xcode (24)
  • Uruchamianie Xcode (24)
  • Tworzenie pierwszego programu C++ w Xcode (24)
  • Instalowanie Xcode 4 (28)
  • Uruchamianie Xcode (28)
  • Tworzenie pierwszego programu C++ w Xcode (28)
  • Rozwiązywanie problemów (31)
• Linux (33)
• Krok 1. Instalowanie g++ (33)
• Krok 2. Uruchomienie g++ (34)
• Krok 3. Uruchomienie programu (34)
• Krok 4. Konfigurowanie edytora tekstowego (35)
• Konfigurowanie nano (35)
• Korzystanie z nano (36)

Rozdział 2. Podstawy C++ (39)

• Wprowadzenie do języka C++ (39)
  
  • Najprostszy program w C++ (39)
  • Co się dzieje, jeżeli nie możesz zobaczyć swojego programu? (41)
  • Podstawowa struktura programu w C++ (42)
• Komentowanie programów (42)
• Specyfika myślenia programisty. Tworzenie kodu wielokrotnego użycia (43)
• Kilka słów na temat radości i bólu praktyki (44)
• Sprawdź się (44)
• Zadania praktyczne (45)

Rozdział 3. Interakcja z użytkownikiem. Zapisywanie informacji w zmiennych (47)

• Deklarowanie zmiennych w C++ (47)
• Korzystanie ze zmiennych (48)
• Co zrobić, gdy program błyskawicznie kończy działanie? (48)
• Zmiana wartości zmiennych oraz ich porównywanie (49)
• Skrócone zapisy na dodawanie i odejmowanie jedynki (50)
• Poprawne i niepoprawne użycie zmiennych (51)
  
  • Najczęściej popełniane błędy podczas deklarowania zmiennych w C++ (51)
  • Rozróżnianie wielkości liter (52)
  • Nazwy zmiennych (53)
• Przechowywanie łańcuchów tekstowych (53)
• No dobrze, rozumiem już łańcuchy tekstowe, ale co z pozostałymi typami? (55)
  
  • Mały sekret liczb zmiennoprzecinkowych (56)
  • Mały sekret liczb całkowitych (57)
• Sprawdź się (57)
• Zadania praktyczne (58)

Rozdział 4. Instrukcje warunkowe (59)

• Podstawowa składnia instrukcji if (59)
• Wyrażenia (60)
  
  • Czym jest prawda? (61)
  • Typ bool (61)
• Instrukcja else (62)
• Instrukcje else-if (62)
• Porównywanie łańcuchów tekstowych (63)
• Więcej interesujących warunków budowanych za pomocą operatorów logicznych (64)
  
  • Logiczne nie (64)
  • Logiczne ORAZ (65)
  • Logiczne LUB (65)
  • Łączenie wyrażeń (66)
  • Przykładowe wyrażenia logiczne (67)
• Sprawdź się (67)
• Zadania praktyczne (68)

Rozdział 5. Pętle (69)

• Pętla while (69)
  
  • Najczęściej popełniany błąd (70)
• Pętla for (70)
  
  • Inicjalizacja zmiennej (71)
  • Warunek pętli (71)
  • Aktualizacja zmiennej (71)
• Pętla do-while (72)
• Kontrolowanie przebiegu pętli (73)
• Pętle zagnieżdżone (75)
• Wybór właściwego rodzaju pętli (76)
  
  • Pętla for (76)
  • Pętla while (76)
  • Pętla do-while (77)
• Sprawdź się (78)
• Zadania praktyczne (78)

Rozdział 6. Funkcje (81)

• Składnia funkcji (81)
• Zmienne lokalne i zmienne globalne (83)
  
  • Zmienne lokalne (83)
  • Zmienne globalne (84)
  • Ostrzeżenie dotyczące zmiennych globalnych (85)
• Przygotowanie funkcji do użycia (86)
  
  • Definicja i deklaracja funkcji (86)
  • Przykład użycia prototypu funkcji (87)
• Rozbijanie programu na funkcje (88)
  
  • Kiedy wciąż na nowo powtarzasz ten sam kod (88)
  • Kiedy chcesz, żeby kod był łatwiejszy do czytania (88)
• Nazywanie i przeładowywanie funkcji (89)
• Podsumowanie wiadomości o funkcjach (89)
• Sprawdź się (90)
• Zadania praktyczne (90)

Rozdział 7. Instrukcje switch case oraz typ wyliczeniowy (91)

• Porównanie instrukcji switch case z if (93)
• Tworzenie prostych typów za pomocą wyliczeń (94)
• Sprawdź się (96)
• Zadania praktyczne (96)

Rozdział 8. Dodawanie do programu elementu losowości (97)

• Uzyskiwanie liczb losowych w C++ (98)
• Błędy i losowość (100)
• Sprawdź się (101)
• Zadania praktyczne (102)

Rozdział 9. Co zrobić, kiedy1 nie wiesz, co robić? (103)

• Krótka dygresja na temat wydajności i bezpieczeństwa kodu (106)
• Co robić, kiedy nie znasz algorytmu? (107)
• Zadania praktyczne (110)

CZĘŚĆ II. PRACA Z DANYMI (111)

Rozdział 10. Tablice (113)

• Podstawowa składnia tablic (113)
• Przykładowe zastosowania tablic (114)
  
  • Przechowywanie zamówień w tablicach (114)
  • Odwzorowanie siatek w tablicach wielowymiarowych (115)
• Korzystanie z tablic (115)
  
  • Tablice i pętle (115)
  • Przekazywanie tablic do funkcji (116)
  • Wypadnięcie poza ostatni element tablicy (118)
• Sortowanie tablic (118)
• Sprawdź się (122)
• Zadania praktyczne (123)

Rozdział 11. Struktury (125)

• Wiązanie wielu wartości (125)
  
  • Składnia (125)
  • Przekazywanie struktur (127)
• Sprawdź się (129)
• Zadania praktyczne (130)

Rozdział 12. Wprowadzenie do wskaźników (131)

• Zapomnij o wszystkim, co do tej pory słyszałeś (131)
• No dobrze, czym są wskaźniki? Dlaczego powinny mnie obchodzić? (131)
• Czym jest pamięć komputera? (132)
  
  • Zmienne a adresy (133)
  • Uwaga na temat nazewnictwa (133)
• Organizacja pamięci (134)
  
  • Nieprawidłowe wskaźniki (135)
  • Pamięć i tablice (136)
• Pozostałe zalety i wady wskaźników (136)
• Sprawdź się (137)
• Zadania praktyczne (137)

Rozdział 13. Korzystanie ze wskaźników (139)

• Składnia wskaźników (139)
  
  • Deklarowanie wskaźnika (139)
• Otrzymywanie adresu zmiennej za pomocą wskaźnika (140)
  
  • Użycie wskaźnika (140)
• Niezainicjalizowane wskaźniki i wartość NULL (143)
• Wskaźniki i funkcje (144)
• Referencje (146)
  
  • Referencje a wskaźniki (147)
• Sprawdź się (148)
• Zadania praktyczne (148)

Rozdział 14. Dynamiczna alokacja pamięci (151)

• Pozyskiwanie pamięci za pomocą instrukcji new (151)
  
  • Brak pamięci (152)
  • Referencje i dynamiczna alokacja (152)
• Wskaźniki i tablice (152)
• Tablice wielowymiarowe (155)
• Arytmetyka wskaźników (155)
  
  • Zrozumieć tablice dwuwymiarowe (156)
  • Wskaźniki do wskaźników (157)
  • Wskaźniki do wskaźników i tablic dwuwymiarowych (159)
• Oswajanie wskaźników (160)
• Sprawdź się (160)
• Zadania praktyczne (161)

Rozdział 15. Wprowadzenie do struktur danych: listy powiązane (163)

• Wskaźniki i struktury (165)
• Tworzenie listy powiązanej (166)
  
  • Pierwszy przebieg (167)
  • Drugi przebieg (168)
• Przeglądanie listy powiązanej (169)
• Oswajanie list powiązanych (170)
  
  • Tablice a listy powiązane (171)
• Sprawdź się (173)
• Zadania praktyczne (175)

Rozdział 16. Rekurencja (177)

• Jak postrzegać rekurencję? (177)
• Rekurencja i struktury danych (179)
• Pętle i rekurencja (181)
• Stos (183)
  
  • Zaleta stosu (185)
  • Wady rekurencji (185)
  • Debugowanie przepełnienia stosu (186)
  • Wydajność (188)
• Oswajanie rekurencji (188)
• Sprawdź się (188)
• Zadania praktyczne (189)

Rozdział 17. Drzewa binarne (191)

• Konwencje nazewnicze (193)
• Implementacja drzew binarnych (194)
• Wstawianie węzła do drzewa (194)
• Przeszukiwanie drzewa (196)
• Niszczenie drzewa (197)
• Usuwanie węzła z drzewa (199)
• Praktyczne zastosowanie drzew binarnych (206)
  
  • Koszt tworzenia drzew i map (207)
• Sprawdź się (208)
• Zadania praktyczne (208)

Rozdział 18. Standardowa biblioteka szablonów (211)

• Wektor - tablica o zmiennych rozmiarach (212)
  
  • Przekazywanie wektorów do metod (213)
  • Inne właściwości wektorów (213)
• Mapy (214)
• Iteratory (215)
  
  • Sprawdzanie, czy wartość znajduje się w mapie (217)
• Oswajanie biblioteki STL (218)
• Więcej informacji o STL (219)
• Sprawdź się (219)
• Zadania praktyczne (220)

Rozdział 19. Więcej o łańcuchach tekstowych (221)

• Wczytywanie łańcuchów tekstowych (221)
• Długość łańcucha i dostęp do jego elementów (223)
• Wyszukiwanie i podłańcuchy (224)
• Przekazywanie łańcucha przez referencję (225)
  
  • Szerzenie się const (226)
  • Const i STL (227)
• Sprawdź się (228)
• Zadania praktyczne (229)

Rozdział 20. Debugowanie w Code::Blocks (231)

• Zaczynamy (232)
• Wstrzymywanie działania programu (233)
  
  • Debugowanie awarii (239)
  • Zaglądanie do zawieszonego programu (242)
  • Modyfikowanie zmiennych (245)
  • Podsumowanie (246)
• Zadania praktyczne (246)
• Zadanie nr 1. Problem z wykładnikiem (246)
• Zadanie nr 2. Problem z dodawaniem liczb (247)
• Zadanie nr 3. Problem z ciągiem Fibonacciego (247)
• Zadanie nr 4. Problem z odczytywaniem i wyświetlaniem listy (248)

CZĘŚĆ III. TWORZENIE WIĘKSZYCH PROGRAMÓW (249)

Rozdział 21. Rozbijanie programów na mniejsze części (251)

• Proces kompilacji w języku C++ (251)
  
  • Przetwarzanie wstępne (252)
  • Kompilacja (253)
  • Konsolidacja (253)
  • Dlaczego kompilacja i konsolidacja przebiegają oddzielnie? (254)
• Jak rozbić program na wiele plików? (254)
  
  • Krok 1. Oddzielanie deklaracji od definicji (255)
  • Krok 2. Określenie, które funkcje powinny być wspólne (255)
  • Krok 3. Przeniesienie wspólnych funkcji do nowych plików (255)
  • Przykładowy program (256)
  • Pozostałe zasady pracy z plikami nagłówkowymi (259)
  • Praca z wieloma plikami źródłowymi w środowisku programistycznym (260)
• Sprawdź się (262)
• Zadania praktyczne (264)

Rozdział 22. Wprowadzenie do projektowania programów (265)

• Powielony kod (265)
• Założenia dotyczące przechowywania danych (266)
• Projekt i komentarze (268)
• Sprawdź się (269)

Rozdział 23. Ukrywanie reprezentacji struktur danych (271)

• Użycie funkcji w celu ukrycia układu struktury (272)
• Deklaracja metody i składnia wywołania (273)
  
  • Przeniesienie definicji funkcji poza strukturę (274)
• Sprawdź się (275)
• Zadania praktyczne (275)

Rozdział 24. Klasa (277)

• Ukrywanie sposobu przechowywania danych (278)
• Deklarowanie instancji klasy (279)
• Odpowiedzialności klasy (280)
  
  • Co tak naprawdę znaczy private? (281)
• Podsumowanie (281)
• Sprawdź się (281)
• Zadania praktyczne (282)

Rozdział 25. Cykl życia klasy (283)

• Konstruowanie obiektu (283)
  
  • Co się stanie, jeśli nie utworzysz konstruktora? (285)
  • Inicjalizacja składowych klasy (286)
  • Użycie listy inicjalizacyjnej do pól stałych (287)
• Niszczenie obiektu (288)
  
  • Niszczenie podczas usuwania (290)
  • Niszczenie przy wyjściu poza zakres (290)
  • Niszczenie przez inny destruktor (291)
• Kopiowanie klas (291)
  
  • Operator przypisania (292)
  • Konstruktor kopiujący (295)
  • Pełna lista metod generowanych przez kompilator (296)
  • Całkowite zapobieganie kopiowaniu (296)
• Sprawdź się (297)
• Zadania praktyczne (298)

Rozdział 26. Dziedziczenie i polimorfizm (299)

• Dziedziczenie w C++ (300)
  
  • Pozostałe zastosowania oraz nieprawidłowe użycia dziedziczenia (304)
  • Dziedziczenie, konstruowanie obiektów oraz ich niszczenie (304)
  • Polimorfizm i dziedziczenie obiektów (306)
  • Problem przycinania (308)
  • Dzielenie kodu z podklasami (309)
  • Dane chronione (309)
  • Dane obejmujące całą klasę (310)
  • W jaki sposób zaimplementowany jest polimorfizm? (311)
• Sprawdź się (313)
• Zadania praktyczne (314)

Rozdział 27. Przestrzenie nazw (317)

• Kiedy stosować instrukcję using namespace (319)
• Kiedy należy utworzyć przestrzeń nazw? (319)
• Sprawdź się (320)
• Zadania praktyczne (320)

Rozdział 28. Plikowe operacje wejścia-wyjścia (321)

• Podstawy plikowych operacji wejścia-wyjścia (321)
  
  • Czytanie z plików (321)
• Formaty plików (323)
  
  • Koniec pliku (324)
• Zapisywanie plików (326)
  
  • Tworzenie nowych plików (327)
• Pozycja pliku (327)
• Pobieranie argumentów z wiersza poleceń (330)
  
  • Obsługa argumentów liczbowych (332)
• Pliki binarne (332)
  
  • Praca z plikami binarnymi (334)
  • Konwersja na typ char* (335)
  • Przykład binarnych operacji we/wy (335)
  • Przechowywanie klas w pliku (336)
  • Czytanie z pliku (338)
• Sprawdź się (340)
• Zadania praktyczne (341)

Rozdział 29. Szablony w C++ (343)

• Szablony funkcji (343)
  
  • Inferencja typów (345)
  • Kacze typowanie (345)
• Szablony klas (346)
• Wskazówki dotyczące pracy z szablonami (347)
  
  • Szablony i pliki nagłówkowe (349)
• Podsumowanie informacji o szablonach (349)
  
  • Interpretacja komunikatów o błędach w szablonach (350)
• Sprawdź się (353)
• Zadania praktyczne (354)

CZĘŚCI IV. ZAGADNIENIA ROZMAITE (355)

Rozdział 30. Formatowanie danych wyjściowych za pomocą iomanip (357)

• Rozwiązywanie problemów związanych z odstępami (357)
  
  • Określanie szerokości pola za pomocą instrukcji setw (357)
  • Zmiana znaku dopełniającego (358)
  • Trwała zmiana ustawień (358)
• Korzystanie ze znajomości iomanip (359)
• Wyświetlanie liczb (360)
• Określanie precyzji wyświetlanych liczb za pomocą instrukcji setprecision (361)
• A co z pieniędzmi? (361)
• Wyświetlanie liczb o różnych podstawach (362)

Rozdział 31. Wyjątki i raportowanie błędów (363)

• Zwalnianie zasobów po wystąpieniu wyjątku (364)
• Ręczne czyszczenie zasobów w bloku catch (365)
• Zgłaszanie wyjątków (366)
• Specyfikacja wyjątków (367)
• Korzyści płynące z wyjątków (368)
• Nieprawidłowe użycie wyjątków (369)
• Podsumowanie informacji o wyjątkach (370)

Rozdział 32. Końcowe przemyślenia (371)

• Rozwiązanie testu z rozdziału 2. (372)
• Rozwiązanie testu z rozdziału 3. (373)
• Rozwiązanie testu z rozdziału 4. (374)
• Rozwiązanie testu z rozdziału 5. (374)
• Rozwiązanie testu z rozdziału 6. (375)
• Rozwiązanie testu z rozdziału 7. (375)
• Rozwiązanie testu z rozdziału 8. (376)
• Rozwiązanie testu z rozdziału 10. (377)
• Rozwiązanie testu z rozdziału 11. (377)
• Rozwiązanie testu z rozdziału 12. (378)
• Rozwiązanie testu z rozdziału 13. (379)
• Rozwiązanie testu z rozdziału 14. (380)
• Rozwiązanie testu z rozdziału 15. (381)
• Rozwiązanie testu z rozdziału 16. (382)
• Rozwiązanie testu z rozdziału 17. (383)
• Rozwiązanie testu z rozdziału 18. (384)
• Rozwiązanie testu z rozdziału 19. (385)
• Rozwiązanie testu z rozdziału 21. (385)
• Rozwiązanie testu z rozdziału 22. (386)
• Rozwiązanie testu z rozdziału 23. (386)
• Rozwiązanie testu z rozdziału 24. (387)
• Rozwiązanie testu z rozdziału 25. (387)
• Rozwiązanie testu z rozdziału 26. (389)
• Rozwiązanie testu z rozdziału 27. (390)
• Rozwiązanie testu z rozdziału 28. (391)
• Rozwiązanie testu z rozdziału 29. (391)

Skorowidz (393)