C++ w 24 godziny. Wydanie VI - ebook

C++ powstał w 1979 roku i doskonale przetrwał próbę czasu, a dziś oferuje programistom potężne możliwości i ogromną elastyczność. Co więcej, istnieją języki programowania, których twórcy inspirowali się właśnie C++; jednym z nich jest Java. Oznacza to, że opanowanie C++ daje wiele korzyści: ułatwia zrozumienie innych języków programowania, a przede wszystkim pozwala na tworzenie aplikacji praktycznie dla wszystkich platform, począwszy od komputerów i serwerów, przez urządzenia mobilne i konsole do gier, aż po komputery typu mainframe.

Dzięki tej książce w ciągu 24 godzinnych lekcji poznasz podstawy programowania w C++ i szybko zaczniesz tworzyć w pełni funkcjonalne aplikacje. Najpierw zapoznasz się z instalacją i użyciem kompilatora, później dowiesz się, jak debugować tworzony kod, aż wreszcie poznasz nowości wprowadzone w standardzie C++14. Dowiesz się, jak zarządzać wejściem i wyjściem oraz jak pracować z pętlami i tablicami. Nauczysz się programowania zorientowanego obiektowo i zobaczysz, jak wykorzystywać szablony. Każda lekcja kończy się zestawem pytań i odpowiedzi, warsztatami oraz ćwiczeniami do samodzielnego wykonania.

Najważniejsze zagadnienia:

• instalacja i korzystanie z kompilatora C++ na platformach Windows, MacOS i Linux
• podstawowe koncepcje C++, takie jak funkcje i klasy
• wyrażenia lambda, wskaźniki i przeciążanie operatorów
• dziedziczenie i polimorfizm
• nowe funkcje języka wprowadzone w standardzie C++14

C++. Programowanie na miarę wyobraźni!

O autorach (11)

Wprowadzenie (13)

CZĘŚĆ I. PODSTAWY C++

Godzina 1. Twój pierwszy program (17)

• Użycie C++ (17)
• Kompilacja i linkowanie kodu źródłowego (18)
• Utworzenie pierwszego programu (19)
• Podsumowanie (21)
• Pytania i odpowiedzi (21)
• Warsztaty (22)

Godzina 2. Organizacja elementów programu (25)

• Dlaczego warto używać C++? (25)
• Poszczególne elementy programu (29)
• Komentarze (31)
• Funkcje (32)
• Podsumowanie (35)
• Pytania i odpowiedzi (35)
• Warsztaty (36)

Godzina 3. Tworzenie zmiennych i stałych (39)

• Czym jest zmienna? (39)
• Definiowanie zmiennej (43)
• Przypisanie wartości zmiennej (45)
• Użycie definicji typu (46)
• Stałe (47)
• Zmienne o automatycznie ustalanym typie (50)
• Podsumowanie (52)
• Pytania i odpowiedzi (52)
• Warsztaty (54)

Godzina 4. Użycie wyrażeń, poleceń i operatorów (57)

• Polecenia (57)
• Wyrażenia (58)
• Operatory (59)
• Konstrukcja warunkowa if-else (66)
• Operatory logiczne (70)
• Trudne do obliczenia wartości wyrażeń (72)
• Podsumowanie (72)
• Pytania i odpowiedzi (73)
• Warsztaty (74)

Godzina 5. Wywoływanie funkcji (77)

• Czym jest funkcja? (77)
• Deklarowanie i definiowanie funkcji (77)
• Użycie zmiennych w funkcjach (80)
• Parametry funkcji (83)
• Zwrot wartości z funkcji (84)
• Parametry domyślne funkcji (86)
• Przeciążanie funkcji (88)
• Automatyczne ustalenie typu wartości zwrotnej (89)
• Podsumowanie (91)
• Pytania i odpowiedzi (91)
• Warsztaty (92)

Godzina 6. Sterowanie przebiegiem działania programu (95)

• Pętle (95)
• Pętla while (95)
• Pętla do-while (99)
• Pętla for (100)
• Konstrukcja switch (105)
• Podsumowanie (107)
• Pytania i odpowiedzi (108)
• Warsztaty (109)

Godzina 7. Przechowywanie informacji w tablicach i ciągach tekstowych (111)

• Czym jest tablica? (111)
• Zapis za końcem tablicy (113)
• Inicjalizacja tablicy (114)
• Tablica wielowymiarowa (115)
• Tablica znaków (118)
• Kopiowanie ciągu tekstowego (120)
• Odczytywanie tablicy za pomocą pętli foreach (121)
• Podsumowanie (122)
• Pytania i odpowiedzi (123)
• Warsztaty (124)

CZĘŚĆ II. KLASY

Godzina 8. Tworzenie prostych klas (127)

• Czym jest typ? (127)
• Utworzenie nowego typu (127)
• Klasy i elementy składowe (128)
• Dostęp do elementów składowych klasy (130)
• Dostęp prywatny kontra publiczny (130)
• Implementacja metod składowych (131)
• Tworzenie i usuwanie obiektów (134)
• Podsumowanie (138)
• Pytania i odpowiedzi (138)
• Warsztaty (139)

Godzina 9. Przejście do klas zaawansowanych (141)

• Metody składowe typu const (141)
• Interfejs kontra implementacja (142)
• Sposób zorganizowania deklaracji klasy i definicji metod (142)
• Implementacja inline (142)
• Klasy, których danymi składowymi są inne klasy (145)
• Podsumowanie (149)
• Pytania i odpowiedzi (150)
• Warsztaty (151)

CZĘŚĆ III. ZARZĄDZANIE PAMIĘCIĄ

Godzina 10. Tworzenie wskaźników (153)

• Poznajemy wskaźnik i jego przeznaczenie (153)
• Stos i sterta (163)
• Wskaźnik null (167)
• Podsumowanie (169)
• Pytania i odpowiedzi (169)
• Warsztaty (170)

Godzina 11. Praca z zaawansowanymi wskaźnikami (173)

• Tworzenie obiektów na stercie (173)
• Usuwanie obiektów ze sterty (173)
• Dostęp do danych składowych za pomocą wskaźników (175)
• Dane składowe na stercie (176)
• Wskaźnik this (178)
• Utracone wskaźniki (179)
• Wskaźniki const (180)
• Wskaźniki const i metody składowe const (181)
• Podsumowanie (182)
• Pytania i odpowiedzi (183)
• Warsztaty (183)

Godzina 12. Tworzenie referencji (185)

• Czym jest referencja? (185)
• Utworzenie referencji (185)
• Użycie operatora adresu (&) z referencją (187)
• Kiedy można stosować referencję? (189)
• Zerowe wskaźniki i zerowe referencje (190)
• Przekazywanie argumentów funkcji przez referencję (190)
• Nagłówki i prototypy funkcji (194)
• Zwracanie kilku wartości (195)
• Podsumowanie (198)
• Pytania i odpowiedzi (198)
• Warsztaty (199)

Godzina 13. Zaawansowane referencje i wskaźniki (201)

• Przekazywanie przez referencje zwiększa efektywność działania programu (201)
• Przekazywanie wskaźnika const (204)
• Referencje jako alternatywa dla wskaźników (207)
• Kiedy używać wskaźników, a kiedy referencji (209)
• Zwracanie referencji do obiektu, którego nie ma w danym zasięgu (209)
• Problem związany ze zwracaniem referencji do obiektu na stercie (210)
• Wskaźnik, wskaźnik, kto ma wskaźnik? (212)
• Podsumowanie (213)
• Pytania i odpowiedzi (213)
• Warsztaty (214)

CZĘŚĆ IV. ZAAWANSOWANY C++

Godzina 14. Wywoływanie funkcji zaawansowanych (217)

• Przeciążanie metod składowych (217)
• Użycie wartości domyślnych (219)
• Inicjalizacja obiektów (221)
• Konstruktor kopiujący (222)
• Wyrażenia stałych podczas kompilacji (226)
• Podsumowanie (228)
• Pytania i odpowiedzi (228)
• Warsztaty (229)

Godzina 15. Przeciążanie operatorów (231)

• Przeciążanie operatorów (231)
• Operatory konwersji (241)
• Podsumowanie (244)
• Pytania i odpowiedzi (245)
• Warsztaty (246)

CZĘŚĆ V. DZIEDZICZENIE I POLIMORFIZM

Godzina 16. Rozszerzanie klas za pomocą dziedziczenia (249)

• Czym jest dziedziczenie? (249)
• Prywatne kontra chronione (252)
• Konstruktory i destruktory (254)
• Przekazywanie argumentów do konstruktorów bazowych (256)
• Nadpisywanie funkcji (261)
• Podsumowanie (266)
• Pytania i odpowiedzi (266)
• Warsztaty (267)

Godzina 17. Użycie polimorfizmu i klas potomnych (269)

• Polimorfizm implementowany za pomocą wirtualnych metod składowych (269)
• Jak działają metody wirtualne? (273)
• Podsumowanie (281)
• Pytania i odpowiedzi (281)
• Warsztaty (282)

Godzina 18. Wykorzystanie polimorfizmu zaawansowanego (285)

• Problem z pojedynczym dziedziczeniem (285)
• Abstrakcyjne typy danych (289)
• Podsumowanie (301)
• Pytania i odpowiedzi (301)
• Warsztaty (302)

CZĘŚĆ VI. TEMATY SPECJALNE

Godzina 19. Przechowywanie informacji na liście (305)

• Listy i inne struktury (305)
• Studium przypadku struktury listy (306)
• Struktura listy jako obiekt (315)
• Podsumowanie (316)
• Pytania i odpowiedzi (316)
• Warsztaty (317)

Godzina 20. Użycie specjalnych klas, funkcji i wskaźników (319)

• Statyczne dane składowe (319)
• Statyczna metoda składowa (321)
• Zawieranie się klas (323)
• Zaprzyjaźnione klasy i metody (330)
• Podsumowanie (344)
• Pytania i odpowiedzi (344)
• Warsztaty (345)

Godzina 21. Użycie nowych funkcji standardu C++14 (347)

• Najnowsza wersja C++ (347)
• Użycie auto w typie wartości zwrotnej funkcji (348)
• Słowo kluczowe constexpr (352)
• Wyrażenia lambda (354)
• Podsumowanie (355)
• Pytania i odpowiedzi (355)
• Warsztaty (356)

Godzina 22. Analiza i projekt zorientowany obiektowo (359)

• Cykl programistyczny (359)
• Symulacja systemu alarmowego (360)
• PostMaster - studium przypadku (366)
• Podsumowanie (385)
• Pytania i odpowiedzi (386)
• Warsztaty (386)

Godzina 23. Tworzenie szablonów (389)

• Czym są szablony? (389)
• Egzemplarze szablonu (390)
• Definicja szablonu (390)
• Użycie elementów szablonu (396)
• Podsumowanie (402)
• Pytania i odpowiedzi (402)
• Warsztaty (403)

Godzina 24. Obsługa wyjątków i błędów (405)

• Pluskwy, błędy, pomyłki i "psujący się" kod (405)
• Sytuacje wyjątkowe (406)
• Wyjątki (407)
• Użycie bloków try i catch (411)
• Tworzenie kodu o profesjonalnej jakości (416)
• Podsumowanie (422)
• Pytania i odpowiedzi (422)
• Warsztaty (422)

DODATKI

Dodatek A. Systemy dwójkowy i szesnastkowy (425)

• Inne podstawy (425)
• Konwertowanie na inną podstawę (426)
• Szesnastkowo (429)

Dodatek B. Słowniczek (433)

Dodatek C. Witryna internetowa książki (441)

Dodatek D. Użycie kompilatora MinGW C++ w Windows (443)

• Pobieranie MinGW-w64 (443)
• Konfiguracja zmiennej środowiskowej Path (444)
• Przetestowanie instalacji (447)

Skorowidz (451)