Używamy cookies, aby ułatwić korzystanie z Portalu. Możesz określić warunki przechowywania, dostępu do plików cookies w Twojej przeglądarce. Dowiedz się więcej.
strona główna Strona główna | Nowości | Promocje | Zapowiedzi Twoje konto | Zarejestruj | Schowek | Kontakt | Pomoc
mapa działów
Szukaj: szukanie zaawansowane
Koszyk
Książki \ Programowanie \ C++

C++ w 24 godziny. Wydanie VI Język: 1

978-83-283-3551-6

Cena Brutto: 79.00

Cena netto: 75.24

Ilość:
Wersja: Drukowana
Autor Rogers Cadenhead, Jesse Liberty
Liczba_stron 456
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2017-09-29

C++ w 24 godziny. Wydanie VI


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

    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)

powrót
 
Produkty Podobne
C++. Zadania z programowania z przykładowymi rozwiązaniami. Wydanie II
C++ w 24 godziny. Wydanie VI
C++ Templates: The Complete Guide, 2nd Edition
Wzorce projektowe. Leksykon kieszonkowy
C++ in One Hour a Day, Sams Teach Yourself, 8th Edition
Zestaw 2 książek C++ (C++ Optymalizacja kodu + Skuteczny nowoczesny C++)
Advanced Qt Programming. Creating Great Software with C++ and Qt 4
C++ Optymalizacja kodu. Sprawdzone techniki zwiększania wydajności
Język C/C++ i obliczenia numeryczne. Krótkie wprowadzenie
C++ in 24 Hours, Sams Teach Yourself, 6th Edition
Więcej produktów