C++ w 24 godziny. Wydanie VI - ebook
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!
Spis treści
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)
| Kategoria: | Programowanie |
| Zabezpieczenie: |
Watermark
|
| ISBN: | 978-83-283-3552-3 |
| Rozmiar pliku: | 3,6 MB |
