Деталі електронної книги

C++ w 24 godziny. Wydanie VI

C++ w 24 godziny. Wydanie VI

Rogers Cadenhead, Jesse Liberty

Eлектронна книга

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)

  • Назва: C++ w 24 godziny. Wydanie VI
  • Автор: Rogers Cadenhead, Jesse Liberty
  • Оригінальна назва: C++ in 24 Hours, Sams Teach Yourself (6th Edition)
  • Переклад: Robert Górczyński
  • ISBN: 978-83-283-3552-3, 9788328335523
  • Дата видання: 2017-09-29
  • Формат: Eлектронна книга
  • Ідентифікатор видання: cpp246
  • Видавець: Helion