E-book details

C++. Dla każdego. Wydanie VII

C++. Dla każdego. Wydanie VII

Siddhartha Rao

Ebook

Programowanie w Twoim zasięgu!

Pomimo swojego wieku C++ wciąż zajmuje wysoką lokatę na liście najpopularniejszych języków programowania. Przez lata dzięki wydajności oraz dostępności zdobył sobie licznych wielbicieli i wciąż jest niezastąpiony w wielu zadaniach, choć w branży przewagę nad nim mają język Java i platforma .NET. Jeżeli jednak oczekujesz najwyższej wydajności i przewidywalnego czasu wykonania zadania, język C++ może okazać się jedynym słusznym wyborem.

Z tą książką opanujesz język C++ bez trudu, poświęcając na to tylko godzinę dziennie! W trakcie lektury zgłębisz jego tajniki, poznasz zalety oraz wady. Każda kolejna godzina to coraz bardziej zaawansowana, a przy tym ciekawsza dawka wiedzy. Opanowanie materiału zawartego w podręczniku pozwoli Ci na pisanie programów o różnym stopniu złożoności oraz swobodne poruszanie się w świecie języka C++. W trakcie lektury opanujesz składnię i elementy języka - tablice, instrukcje warunkowe, pętle czy stałe nie będą miały przed Tobą żadnych tajemnic. W kolejnych rozdziałach dowiesz się, jak wykorzystać wskaźniki i dyrektywy kompilatora. Ponadto zaznajomisz się z zasadami programowania obiektowego oraz poznasz nowości zawarte w wersji 11. Książka ta jest doskonałym źródłem wiedzy dla każdego adepta języka C++!

Dzięki tej książce:

  • poznasz składnię języka C++
  • opanujesz nowości wersji 11 języka C++
  • poznasz zasady programowania obiektowego
  • napiszesz program o dowolnym stopniu skomplikowania

Poznaj i wykorzystaj potencjał języka C++!

O autorze (21)

Wstęp (23)

CZĘŚĆ I. PODSTAWY (27)

Lekcja 1. Zaczynamy (29)

  • Krótka historia języka C++ (30)
    • Powiązanie z językiem C (30)
    • Zalety języka C++ (30)
    • Ewolucja standardu C++ (31)
    • Kto używa programów utworzonych w C++? (31)
  • Tworzenie aplikacji C++ (32)
    • Kroki prowadzące do wygenerowania pliku wykonywalnego (32)
    • Analiza błędów i ich usuwanie (33)
    • Zintegrowane środowiska programistyczne (33)
    • Tworzenie pierwszej aplikacji w C++ (34)
    • Kompilacja i uruchomienie pierwszej aplikacji w C++ (35)
    • Błędy kompilacji (37)
  • Co nowego w C++11? (37)
  • Podsumowanie (38)
  • Pytania i odpowiedzi (38)
  • Warsztaty (39)

Lekcja 2. Anatomia programu C++ (41)

  • Komponenty programu (42)
    • Dyrektywa preprocesora #include (42)
    • Część główna programu - funkcja main() (43)
    • Wartość zwrotna (44)
  • Koncepcja przestrzeni nazw (45)
  • Komentarze w kodzie C++ (47)
  • Funkcje w C++ (48)
  • Podstawowe wejście za pomocą std::cin i wyjście za pomocą std::cout (51)
  • Podsumowanie (53)
  • Pytania i odpowiedzi (53)
  • Warsztaty (54)

Lekcja 3. Zmienne i stałe (55)

  • Czym jest zmienna? (56)
    • Ogólne omówienie pamięci i adresowania (56)
    • Deklarowanie zmiennych uzyskujących dostęp i używających pamięci (56)
    • Deklarowanie i inicjalizowanie wielu zmiennych tego samego typu (59)
    • Zrozumienie zakresu zmiennej (59)
    • Zmienne globalne (61)
  • Typy zmiennych najczęściej używane w C++ (63)
    • Użycie typu bool do przechowywania wartości boolowskich (64)
    • Użycie typu char do przechowywania znaków (65)
    • Koncepcja liczb ze znakiem i bez znaku (65)
    • Liczby całkowite ze znakiem, czyli typy short, int, long i long long (66)
    • Liczby całkowite bez znaku, czyli typy unsigned short, unsigned int, unsigned long i unsigned long long (67)
    • Typy zmiennoprzecinkowe float i double (67)
  • Określanie wielkości zmiennej za pomocą sizeof (68)
  • Użycie typedef do zastąpienia typu zmiennej (72)
  • Czym jest stała? (72)
    • Dosłowne stałe (73)
    • Deklarowanie zmiennych jako stałych przy użyciu const (74)
    • Deklarowanie stałych za pomocą constexpr (75)
    • Stałe typu wyliczeniowego (76)
    • Definiowanie stałych za pomocą dyrektywy #define (78)
  • Nazwy zmiennych i stałych (79)
  • Słowa kluczowe, których nie można używać jako nazw zmiennych lub stałych (80)
  • Podsumowanie (80)
  • Pytania i odpowiedzi (81)
  • Warsztaty (84)

Lekcja 4. Tablice i ciągi tekstowe (85)

  • Czym jest tablica? (86)
    • Kiedy trzeba użyć tablicy? (86)
    • Deklarowanie i inicjalizacja tablic statycznych (87)
    • Jak w tablicy przechowywane są dane? (88)
    • Uzyskanie dostępu do danych przechowywanych w tablicy (90)
    • Modyfikacja danych przechowywanych w tablicy (91)
  • Tablice wielowymiarowe (94)
    • Deklarowanie i inicjalizowanie tablic wielowymiarowych (95)
    • Uzyskanie dostępu do elementów tablicy wielowymiarowej (95)
  • Tablice dynamiczne (97)
  • Ciągi tekstowe w stylu C (99)
  • Ciągi tekstowe C++ - użycie klasy std::string (102)
  • Podsumowanie (104)
  • Pytania i odpowiedzi (105)
  • Warsztaty (106)

Lekcja 5. Wyrażenia, instrukcje i operatory (109)

  • Polecenia (110)
  • Polecenia złożone, czyli bloki (111)
  • Użycie operatorów (111)
    • Operator przypisania (=) (111)
    • Zrozumienie l-wartości i r-wartości (112)
    • Operatory dodawania (+), odejmowania (-), mnożenia (*), dzielenia (/) i reszty z dzielenia (%) (112)
    • Operatory inkrementacji (++) i dekrementacji (--) (113)
    • Operator postfiksowy czy prefiksowy? (114)
    • Operatory równości (==) i nierówności (!=) (117)
    • Operatory relacji (118)
    • Operatory logiczne NOT, AND, OR i XOR (120)
    • Użycie w C++ operatorów logicznych NOT (!), AND (&&) i OR (||) (122)
    • Bitowe operatory NOT (~), AND (&), OR (|) i XOR (^) (126)
    • Operatory bitowego przesunięcia w prawo (>>) oraz w lewo (<<) (128)
    • Złożone operatory przypisania (130)
    • Użycie operatora sizeof w celu określenia ilości pamięci zajmowanej przez zmienną (132)
    • Pierwszeństwo operatorów (133)
  • Podsumowanie (136)
  • Pytania i odpowiedzi (136)
  • Warsztaty (137)

Lekcja 6. Sterowanie przebiegiem działania programu (139)

  • Wykonanie warunkowe za pomocą if-else (140)
    • Programowanie warunkowe z użyciem if-else (141)
    • Warunkowe wykonanie wielu poleceń (143)
    • Zagnieżdżone polecenia if (145)
    • Przetwarzanie warunkowe za pomocą switch-case (149)
    • Wykonywanie warunkowe przy użyciu operatora ?: (153)
  • Wykonywanie kodu w pętlach (154)
    • Bardzo prosta pętla wykonywana przy użyciu polecenia goto (155)
    • Pętla while (157)
    • Pętla do...while (159)
    • Pętla for (161)
  • Zmiana zachowania pętli za pomocą poleceń continue i break (165)
    • Pętle działające w nieskończoność (165)
    • Kontrolowanie pętli działającej w nieskończoność (166)
  • Programowanie zagnieżdżonych pętli (169)
    • Użycie zagnieżdżonych pętli do iteracji tablic wielowymiarowych (171)
    • Użycie zagnieżdżonych pętli do obliczenia liczb ciągu Fibonacciego (173)
  • Podsumowanie (174)
  • Pytania i odpowiedzi (175)
  • Warsztaty (176)

Lekcja 7. Funkcje (179)

  • Kiedy należy stosować funkcje? (180)
    • Czym jest prototyp funkcji? (181)
    • Czym jest definicja funkcji? (182)
    • Czym jest wywołanie funkcji i argumenty? (182)
    • Tworzenie funkcji z wieloma parametrami (183)
    • Tworzenie funkcji bez parametrów i bez wartości zwrotnej (185)
    • Parametry funkcji wraz z wartościami domyślnymi (186)
    • Rekurencja, czyli funkcja wywołująca samą siebie (188)
    • Funkcje z wieloma poleceniami return (190)
  • Użycie funkcji do pracy z różnymi formami danych (191)
    • Przeciążanie funkcji (192)
    • Przekazanie funkcji tablicy wartości (194)
    • Przekazywanie argumentów przez referencję (195)
  • Jak wywołania funkcji są obsługiwane przez mikroprocesor? (197)
    • Funkcje typu inline (198)
    • Funkcja lambda (200)
  • Podsumowanie (202)
  • Pytania i odpowiedzi (203)
  • Warsztaty (204)

Lekcja 8. Wskaźniki i referencje (207)

  • Czym jest wskaźnik? (208)
    • Deklaracja wskaźnika (208)
    • Określenie adresu zmiennej przy użyciu operatora referencji (&) (209)
    • Użycie wskaźników do przechowywania adresów (210)
    • Uzyskanie dostępu do danych przy użyciu operatora dereferencji (*) (213)
    • Ile pamięci zabiera wskaźnik? (216)
  • Dynamiczna alokacja pamięci (218)
    • Użycie operatorów new i delete w celu dynamicznej alokacji i zwalniania pamięci (218)
    • Efektywne użycie operatorów inkrementacji (++) i dekrementacji (--) na wskaźnikach (222)
    • Użycie słowa kluczowego const ze wskaźnikami (225)
    • Przekazywanie wskaźników funkcjom (227)
    • Podobieństwa pomiędzy tablicami i wskaźnikami (228)
  • Najczęstsze błędy programistyczne popełniane podczas używania wskaźników (231)
    • Wycieki pamięci (232)
    • Kiedy wskaźnik nie prowadzi do poprawnego adresu w pamięci? (232)
    • Zawieszone wskaźniki (nazywane również zabłąkanymi) (234)
  • Najlepsze praktyki podczas pracy ze wskaźnikami (234)
    • Sprawdzenie, czy żądanie alokacji zakończyło się powodzeniem (236)
  • Czym jest referencja? (240)
    • Dlaczego referencje są użyteczne? (241)
    • Użycie słowa kluczowego const w referencjach (243)
    • Przekazywanie funkcji argumentów przez referencję (243)
  • Podsumowanie (245)
  • Pytania i odpowiedzi (245)
  • Warsztaty (247)

CZĘŚĆ II. PODSTAWY PROGRAMOWANIA ZORIENTOWANEGO OBIEKTOWO W C++ (249)

Lekcja 9. Klasy i obiekty (251)

  • Koncepcja klas i obiektów (252)
    • Deklarowanie klasy (252)
    • Tworzenie obiektu klasy (253)
    • Uzyskanie dostępu do elementów składowych przy użyciu operatora kropki (254)
    • Uzyskanie dostępu do elementów składowych przy użyciu operatora wskaźnika (255)
  • Słowa kluczowe public i private (257)
    • Abstrakcja danych dzięki słowu kluczowemu private (259)
  • Konstruktory (261)
    • Deklarowanie i implementowanie konstruktora (261)
    • Kiedy i jak używać konstruktorów? (262)
    • Przeciążanie konstruktorów (264)
    • Klasa bez konstruktora domyślnego (267)
    • Parametry konstruktora wraz z wartościami domyślnymi (269)
    • Konstruktory wraz z listami inicjalizacyjnymi (270)
  • Destruktor (272)
    • Deklarowanie i implementowanie destruktora (272)
    • Kiedy i jak używać destruktorów? (273)
  • Konstruktor kopiujący (276)
    • Kopiowanie płytkie i związane z tym problemy (276)
    • Wykonanie głębokiej kopii przy użyciu konstruktora kopiującego (279)
    • Konstruktory przenoszące pomagają w poprawieniu wydajności (284)
  • Różne sposoby użycia konstruktorów i destruktora (286)
    • Klasa, której nie można kopiować (286)
    • Klasa typu Singleton, która pozwala na istnienie tylko jednego egzemplarza (287)
    • Klasy, których egzemplarze nie mogą być tworzone na stosie (290)
  • Wskaźnik this (292)
  • Operator sizeof() dla klasy (293)
  • Jaka jest różnica pomiędzy strukturą i klasą? (297)
  • Deklaracja "przyjaciela" klasy (297)
  • Podsumowanie (300)
  • Pytania i odpowiedzi (300)
  • Warsztaty (302)

Lekcja 10. Dziedziczenie (305)

  • Podstawy dziedziczenia (306)
    • Dziedziczenie i pochodzenie (306)
    • Stosowana w języku C++ składnia pochodzenia (308)
    • Specyfikator dostępu protected (311)
    • Inicjalizacja klasy bazowej - przekazywanie parametrów klasie bazowej (314)
    • Klasy potomne nadpisują metody klasy bazowej (316)
    • Wywoływanie nadpisanych metod klasy bazowej (319)
    • Wywoływanie metod klasy bazowej z poziomu klas potomnych (319)
    • Klasy potomne ukrywają metody klasy bazowej (321)
    • Kolejność użycia konstruktorów (324)
    • Kolejność użycia destruktorów (324)
  • Dziedziczenie prywatne (327)
  • Dziedziczenie chronione (330)
  • Problem segmentowania (333)
  • Dziedziczenie wielokrotne (334)
  • Podsumowanie (337)
  • Pytania i odpowiedzi (338)
  • Warsztaty (339)

Lekcja 11. Polimorfizm (341)

  • Podstawy polimorfizmu (342)
    • Potrzeba stosowania polimorfizmu (342)
    • Zachowanie polimorficzne implementowane przy użyciu funkcji wirtualnych (344)
    • Konieczność stosowania wirtualnych destruktorów (346)
    • Jak działa funkcja wirtualna? Zrozumienie tabeli funkcji wirtualnych (351)
    • Abstrakcyjne klasy bazowe i funkcje czysto wirtualne (355)
  • Użycie dziedziczenia prywatnego do rozwiązania problemu niejednoznaczności semantycznej (358)
  • Wirtualne konstruktory kopiujące? (363)
  • Podsumowanie (367)
  • Pytania i odpowiedzi (367)
  • Warsztaty (368)

Lekcja 12. Typy operatorów i ich przeciążanie (371)

  • Czym są operatory w C++? (372)
  • Operatory jednoargumentowe (373)
    • Typy operatorów jednoargumentowych (373)
    • Programowanie jednoargumentowego operatora inkrementacji i dekrementacji (374)
    • Programowanie operatorów konwersji (378)
    • Programowanie operatora dereferencji (*) i operatora wyboru elementu składowego (->) (380)
  • Operatory dwuargumentowe (384)
    • Typy operatorów dwuargumentowych (385)
    • Programowanie operatorów dodawania (a+b) i odejmowania (a-b) (386)
    • Implementowanie operatorów dodawania/przypisania (+=) i odejmowania/przypisania (-=) (389)
    • Przeciążanie operatorów równości (==) i nierówności (!=) (391)
    • Przeciążanie operatorów <, >, <= i >= (394)
    • Przeciążanie kopiującego operatora przypisania (=) (397)
    • Operatory indeksowania (400)
  • Funkcja operator() (404)
    • Użycie konstruktora przenoszącego i przenoszącego operatora przypisania w wysokowydajnym programowaniu (406)
  • Operatory, których nie można ponownie zdefiniować (413)
  • Podsumowanie (414)
  • Pytania i odpowiedzi (414)
  • Warsztaty (415)

Lekcja 13. Operatory rzutowania (417)

  • Kiedy trzeba skorzystać z rzutowania? (418)
  • Dlaczego rzutowanie w stylu C nie jest popularne wśród niektórych programistów C++? (419)
  • Operatory rzutowania C++ (419)
    • Użycie static_cast (420)
    • Użycie dynamic_cast i identyfikacja typu w czasie działania (421)
    • Użycie reinterpret_cast (425)
    • Użycie const_cast (426)
  • Problemy z operatorami rzutowania C++ (427)
  • Podsumowanie (429)
  • Pytania i odpowiedzi (429)
  • Warsztaty (430)

Lekcja 14. Wprowadzenie do makr i wzorców (433)

  • Preprocesor i kompilator (434)
  • Użycie dyrektywy #define do definiowania stałych (434)
    • Użycie makr do ochrony przed wielokrotnym dołączaniem (437)
  • Użycie dyrektywy #define do definiowania funkcji (438)
    • Po co te wszystkie nawiasy? (440)
    • Użycie makra assert do sprawdzania wyrażeń (441)
    • Wady i zalety użycia funkcji makro (443)
  • Wprowadzenie do wzorców (444)
    • Składnia deklaracji wzorca (445)
    • Różne rodzaje deklaracji wzorca (446)
    • Funkcje wzorca (446)
    • Wzorce i bezpieczeństwo typów (448)
    • Klasy wzorca (449)
    • Ustanawianie i specjalizacja wzorca (450)
    • Deklarowanie wzorców z wieloma parametrami (451)
    • Deklarowanie wzorców z parametrami domyślnymi (452)
    • Przykład wzorca (452)
    • Klasy wzorców i statyczne elementy składowe (454)
    • Użycie static_assert do przeprowadzania operacji sprawdzania w trakcie kompilacji (456)
    • Użycie wzorców w praktycznym programowaniu C++ (457)
  • Podsumowanie (458)
  • Pytania i odpowiedzi (458)
  • Warsztaty (459)

CZĘŚĆ III. POZNAJEMY STANDARDOWĄ BIBLIOTEKĘ WZORCÓW (STL) (461)

Lekcja 15. Wprowadzenie do standardowej biblioteki wzorców (463)

  • Kontenery STL (464)
    • Kontenery sekwencyjne (464)
    • Kontenery asocjacyjne (465)
    • Wybór odpowiedniego kontenera (466)
    • Adaptery (469)
  • Iteratory STL (470)
  • Algorytmy STL (471)
  • Oddziaływania między kontenerami i algorytmami za pomocą iteratorów (472)
    • Użycie słowa kluczowego auto pozwalającego kompilatorowi na definicję typu (474)
  • Klasy STL string (475)
  • Podsumowanie (475)
  • Pytania i odpowiedzi (475)
  • Warsztaty (476)

Lekcja 16. Klasa string w STL (479)

  • Dlaczego potrzebna jest klasa służąca do manipulowania ciągami tekstowymi? (480)
  • Praca z klasą STL string (481)
    • Ustanawianie obiektu STL string i tworzenie kopii (482)
    • Uzyskanie dostępu do obiektu string i jego zawartości (484)
    • Łączenie ciągów tekstowych (487)
    • Wyszukiwanie znaku bądź podciągu tekstowego w obiekcie string (488)
    • Skracanie obiektu STL string (490)
    • Uproszczenie deklaracji iteratora przy użyciu słowa kluczowego auto (493)
    • Odwracanie zawartości ciągu tekstowego (493)
    • Konwersja wielkości znaków obiektu string (494)
  • Implementacja klasy STL string oparta na wzorcach (496)
  • Podsumowanie (496)
  • Pytania i odpowiedzi (497)
  • Warsztaty (497)

Lekcja 17. Dynamiczne klasy tablic w STL (499)

  • Charakterystyka klasy std::vector (500)
  • Typowe operacje klasy vector (500)
    • Ustanawianie klasy vector (500)
    • Wstawianie elementów na końcu przy użyciu push_back() (503)
  • Listy inicjalizacyjne (504)
    • Wstawianie elementów w określonym położeniu przy użyciu metody insert() (504)
    • Uzyskanie dostępu do elementów obiektu vector przy użyciu semantyki tablicy (508)
    • Uzyskanie dostępu do elementów obiektu vector przy użyciu semantyki wskaźnika (510)
    • Usuwanie elementów z obiektu vector (511)
  • Zrozumienie koncepcji wielkości i pojemności (513)
  • Klasa STL deque (515)
  • Podsumowanie (518)
  • Pytania i odpowiedzi (519)
  • Warsztaty (520)

Lekcja 18. Klasy STL list i forward_list (523)

  • Charakterystyka klasy std::list (524)
  • Podstawowe operacje klasy list (524)
    • Ustanawianie obiektu std::list (524)
    • Wstawianie elementów na początku obiektu list (526)
    • Wstawianie elementów w środku obiektu list (529)
    • Usuwanie elementów w obiekcie list (531)
  • Odwrócenie i sortowanie elementów w obiekcie list (533)
    • Odwracanie elementów (534)
    • Sortowanie elementów (535)
    • Sortowanie i usuwanie elementów listy zawierających obiekty danej klasy (538)
  • Podsumowanie (544)
  • Pytania i odpowiedzi (545)
  • Warsztaty (545)

Lekcja 19. Klasy STL set (547)

  • Wprowadzenie do klas STL set (548)
  • Podstawowe operacje klas STL set i multiset (549)
    • Ustanawianie obiektu std::set (549)
    • Wstawianie elementów do obiektów set lub multiset (552)
    • Wyszukiwanie elementów w obiektach STL set lub multiset (554)
    • Usuwanie elementów z obiektów STL set lub multiset (556)
  • Wady i zalety używania obiektów STL set i multiset (562)
  • Podsumowanie (566)
  • Pytania i odpowiedzi (566)
  • Warsztaty (567)

Lekcja 20. Klasy STL map (569)

  • Krótkie wprowadzenie do klas STL map (570)
  • Podstawowe operacje klas STL map i multimap (571)
    • Ustanawianie obiektu std::map lub std::multimap (571)
    • Wstawianie elementów do obiektów STL map lub multimap (573)
    • Wyszukiwanie elementów w obiekcie STL map (577)
    • Wyszukiwanie elementów w obiekcie STL multimap (579)
    • Usuwanie elementów z obiektów STL map lub multimap (580)
  • Dostarczanie własnego predykatu sortowania (583)
    • Jak działa tabela hash? (588)
    • Używanie tabel hash w C++11: unordered_map i unordered_multimap (588)
  • Podsumowanie (593)
  • Pytania i odpowiedzi (593)
  • Warsztaty (594)

CZĘŚĆ IV. JESZCZE WIĘCEJ STL (597)

Lekcja 21. Zrozumienie obiektów funkcji (599)

  • Koncepcja obiektów funkcji i predykatów (600)
  • Typowe aplikacje obiektów funkcji (600)
    • Funkcje jednoargumentowe (600)
    • Predykat jednoargumentowy (606)
    • Funkcje dwuargumentowe (608)
    • Predykat dwuargumentowy (611)
  • Podsumowanie (614)
  • Pytania i odpowiedzi (614)
  • Warsztaty (615)

Lekcja 22. Wyrażenia lambda w C++11 (617)

  • Czym są wyrażenia lambda? (618)
  • W jaki sposób zdefiniować wyrażenie lambda? (619)
  • Wyrażenie lambda dla funkcji jednoargumentowej (619)
  • Wyrażenie lambda dla predykatu jednoargumentowego (621)
  • Wyrażenie lambda wraz ze stanem przy użyciu listy przechwytywania [...] (622)
  • Ogólna składnia wyrażeń lambda (624)
  • Wyrażenie lambda dla funkcji dwuargumentowej (626)
  • Wyrażenie lambda dla predykatu dwuargumentowego (628)
  • Podsumowanie (631)
  • Pytania i odpowiedzi (632)
  • Warsztaty (632)

Lekcja 23. Algorytmy STL (635)

  • Co to są algorytmy STL? (636)
  • Klasyfikacja algorytmów STL (636)
    • Algorytmy niezmienne (636)
    • Algorytmy zmienne (638)
  • Używanie algorytmów STL (640)
    • Znajdowanie elementów o podanej wartości lub warunku (640)
    • Zliczanie elementów o podanej wartości lub warunku (643)
    • Wyszukiwanie elementu lub zakresu w kolekcji (645)
    • Inicjalizacja w kontenerze elementów wraz z określonymi wartościami (648)
    • Użycie std::generate() do inicjalizacji elementów wartościami wygenerowanymi w trakcie działania programu (650)
    • Przetwarzanie elementów w zakresie za pomocą for_each (652)
    • Przeprowadzanie transformacji zakresu za pomocą std::transform (654)
    • Operacje kopiowania i usuwania (657)
    • Zastępowanie wartości oraz zastępowanie elementu na podstawie danego warunku (661)
    • Sortowanie i przeszukiwanie posortowanej kolekcji oraz usuwanie duplikatów (663)
    • Partycjonowanie zakresu (666)
    • Wstawianie elementów do posortowanej kolekcji (669)
  • Podsumowanie (672)
  • Pytania i odpowiedzi (672)
  • Warsztaty (673)

Lekcja 24. Kontenery adaptacyjne: stack i queue (675)

  • Cechy charakterystyczne zachowania stosów i kolejek (676)
    • Stosy (676)
    • Kolejki (676)
  • Używanie klasy STL stack (677)
    • Ustanawianie obiektu stack (677)
    • Funkcje składowe klasy stack (679)
    • Wstawianie i usuwanie elementów z góry stosu przy użyciu metod push() i pop() (679)
  • Używanie klasy STL queue (681)
    • Ustanawianie obiektu queue (682)
    • Funkcje składowe klasy queue (683)
    • Wstawianie na końcu i usuwanie na początku kolejki przy użyciu metod push() i pop() (684)
  • Używanie klasy STL priority_queue (686)
    • Ustanawianie obiektu priority_queue (686)
    • Funkcje składowe klasy priority_queue (688)
    • Wstawianie na końcu i usuwanie na początku kolejki priorytetowej przy użyciu metod push() i pop() (689)
  • Podsumowanie (692)
  • Pytania i odpowiedzi (692)
  • Warsztaty (693)

Lekcja 25. Praca z opcjami bitowymi za pomocą STL (695)

  • Klasa bitset (696)
    • Ustanowienie klasy std::bitset (696)
  • Używanie klasy std::bitset i jej elementów składowych (698)
    • Operatory std::bitset (698)
    • Metody składowe klasy std::bitset (699)
  • Klasa vector<bool> (702)
    • Ustanowienie klasy vector<bool> (702)
    • Używanie klasy vector<bool> (703)
  • Podsumowanie (704)
  • Pytania i odpowiedzi (705)
  • Warsztaty (705)

CZĘŚĆ V. ZAAWANSOWANE KONCEPCJE C++ (707)

Lekcja 26. Sprytne wskaźniki (709)

  • Czym są sprytne wskaźniki? (710)
    • Na czym polega problem związany z używaniem wskaźników konwencjonalnych? (710)
    • W jaki sposób sprytne wskaźniki mogą pomóc? (711)
  • W jaki sposób są implementowane sprytne wskaźniki? (711)
  • Typy sprytnych wskaźników (713)
    • Kopiowanie głębokie (714)
    • Mechanizm kopiowania przy zapisie (COW) (716)
    • Sprytne wskaźniki zliczania odniesień (716)
    • Sprytne wskaźniki powiązane z licznikiem odniesień (717)
    • Kopiowanie destrukcyjne (718)
    • Używanie klasy std::unique_ptr (720)
  • Popularne biblioteki sprytnych wskaźników (722)
  • Podsumowanie (723)
  • Pytania i odpowiedzi (723)
  • Warsztaty (724)

Lekcja 27. Użycie strumieni w operacjach wejścia-wyjścia (727)

  • Koncepcja strumieni (728)
  • Ważne klasy i obiekty strumieni C++ (729)
  • Użycie std::cout do zapisu w konsoli sformatowanych danych (731)
    • Użycie std::cout do zmiany formatu wyświetlanych liczb (731)
    • Wyrównanie tekstu i ustawienie szerokości pola przy użyciu std::cout (734)
  • Użycie std::cin dla danych wejściowych (735)
    • Użycie std::cin w celu umieszczenia danych wejściowych w zmiennych typu POD (735)
    • Użycie std::cin::get w celu umieszczenia danych wejściowych w buforze typu char w stylu C (736)
    • Użycie std::cin w celu umieszczenia danych wejściowych w std::string (738)
  • Użycie std::fstream do obsługi pliku (739)
    • Otwieranie i zamykanie pliku przy użyciu metod open() i close() (740)
    • Tworzenie i zapisywanie tekstu w pliku przy użyciu metody open() i operatora << (741)
    • Odczyt tekstu z pliku przy użyciu metody open() i operatora >> (742)
    • Zapis i odczyt pliku binarnego (744)
  • Użycie std::stringstream do konwersji ciągu tekstowego (746)
  • Podsumowanie (748)
  • Pytania i odpowiedzi (748)
  • Warsztaty (749)
    • Quiz (749)
    • Ćwiczenia (749)

Lekcja 28. Obsługa wyjątków (751)

  • Czym jest wyjątek? (752)
  • Co powoduje zgłoszenie wyjątku? (753)
  • Implementacja bezpieczeństwa wyjątków przy użyciu try i catch (753)
    • Użycie catch(...) do obsługi wszystkich wyjątków (753)
    • Przechwytywanie wyjątku określonego typu (755)
    • Użycie throw do zgłoszenia wyjątku określonego typu (757)
  • Jak działa obsługa wyjątków? (758)
    • Wyjątki klasy std::exception (761)
    • Własna klasa wyjątku wywodząca się z std::exception (762)
  • Podsumowanie (765)
  • Pytania i odpowiedzi (765)
  • Warsztaty (766)

Lekcja 29. Co dalej? (769)

  • Czym wyróżniają się obecnie stosowane procesory? (770)
  • Jak lepiej używać wielu rdzeni? (771)
    • Czym jest wątek? (772)
    • Dlaczego należy tworzyć aplikacje wielowątkowe? (772)
    • Jak wątki wymieniają dane? (773)
    • Użycie muteksu i semaforów do synchronizacji wątków (774)
    • Problemy powodowane przez wielowątkowość (775)
  • Tworzenie doskonałego kodu C++ (776)
  • Ucz się C++. Nie poprzestań na tym, czego się tu dowiedziałeś! (778)
    • Dokumentacja w internecie (778)
    • Społeczności, w których możesz uzyskać porady i pomoc (779)
  • Podsumowanie (779)
  • Pytania i odpowiedzi (780)
  • Warsztaty (780)

DODATKI (781)

Dodatek A. Praca z liczbami: dwójkowo i szesnastkowo (783)

  • System liczb dziesiętnych (784)
  • System liczb dwójkowych (784)
    • Dlaczego w komputerach używany jest system dwójkowy? (785)
    • Czym są bity i bajty? (785)
    • Ile bajtów jest w kilobajcie? (786)
  • System liczb szesnastkowych (786)
    • Dlaczego potrzebujemy systemu szesnastkowego? (787)
  • Konwersja na inną podstawę (787)
    • Ogólny proces konwersji (787)
    • Konwersja liczby dziesiętnej na dwójkową (787)
    • Konwersja liczby dziesiętnej na szesnastkową (788)

Dodatek B. Słowa kluczowe C++ (789)

Dodatek C. Kolejność operatorów (791)

Dodatek D. Odpowiedzi (793)

Dodatek E. Kody ASCII (839)

  • Tabela ASCII znaków wyświetlanych na ekranie (840)

Skorowidz (845)

  • Title: C++. Dla każdego. Wydanie VII
  • Author: Siddhartha Rao
  • Original title: Sams Teach Yourself C++ in One Hour a Day (7th Edition)
  • Translation: Robert Górczyński
  • ISBN: 978-83-246-8078-8, 9788324680788
  • Date of issue: 2014-01-31
  • Format: Ebook
  • Item ID: cppit7
  • Publisher: Helion