Facebook - konwersja

Opus magnum C++11. Programowanie w języku C++ - ebook

Wydawnictwo:
Data wydania:
26 maja 2020
Format ebooka:
PDF
Format PDF
czytaj
na laptopie
czytaj
na tablecie
Format e-booków, który możesz odczytywać na tablecie oraz laptopie. Pliki PDF są odczytywane również przez czytniki i smartfony, jednakze względu na komfort czytania i brak możliwości skalowania czcionki, czytanie plików PDF na tych urządzeniach może być męczące dla oczu. Więcej informacji znajdziesz w dziale Pomoc.
czytaj
na laptopie
Pliki PDF zabezpieczone watermarkiem możesz odczytać na dowolnym laptopie po zainstalowaniu czytnika dokumentów PDF. Najpowszechniejszym programem, który umożliwi odczytanie pliku PDF na laptopie, jest Adobe Reader. W zależności od potrzeb, możesz zainstalować również inny program - e-booki PDF pod względem sposobu odczytywania nie różnią niczym od powszechnie stosowanych dokumentów PDF, które odczytujemy każdego dnia.
Informacje na temat zabezpieczenia e-booka znajdziesz na karcie produktu w "Szczegółach na temat e-booka". Więcej informacji znajdziesz w dziale Pomoc.
czytaj
na tablecie
Aby odczytywać e-booki na swoim tablecie musisz zainstalować specjalną aplikację. W zależności od formatu e-booka oraz systemu operacyjnego, który jest zainstalowany na Twoim urządzeniu może to być np. Bluefire dla EPUBa lub aplikacja Kindle dla formatu MOBI.
Informacje na temat zabezpieczenia e-booka znajdziesz na karcie produktu w "Szczegółach na temat e-booka". Więcej informacji znajdziesz w dziale Pomoc.
199,00

Opus magnum C++11. Programowanie w języku C++ - ebook

Opus magnum C++ 11. Programowanie w języku C++. Wydanie II poprawione" – zestaw obejmuje 3 tomy. Jedno C i same plusy!

Dawno, dawno temu, w głębokich latach osiemdziesiątych ubiegłego wieku pewien duński informatyk zainspirowany językiem C opracował jeden z najważniejszych, najbardziej elastycznych i do dziś niezastąpionych języków programowania - C++. Dziś ten język jest wykorzystywany do tworzenia gier komputerowych, obliczeń naukowych, technicznych, w medycynie, przemyśle i bankowości. NASA posługuje się nim w naziemnej kontroli lotów. Duża część oprogramowania Międzynarodowej Stacji Kosmicznej została napisana w tym języku. Nawet w marsjańskim łaziku Curiosity pracuje program w C++, który analizuje obraz z kamer i planuje dalszą trasę.

Autor tej książki - wybitny specjalista pracujący nad wieloma znaczącymi projektami we francuskich, niemieckich i włoskich instytutach fizyki jądrowej, znany czytelnikom m.in. z genialnej Symfonii C++ - postawił sobie za cel napisanie nowej, przekrojowej książki o tym języku, która w prostym, wręcz przyjacielskim stylu wprowadza czytelnika w fascynujący świat programowania zorientowanego obiektowo. Zobacz, jak potężny jest dzisiaj C++ 11.

Jeżeli chcesz nauczyć się tego języka w łatwy, pogodny, przyjazny sposób, ta książka jest właśnie dla Ciebie.

Dzięki tej książce poznasz:

  • Proste i złożone typy danych
  • Instrukcje sterujące
  • Funkcje i operatory
  • Wskaźniki
  • Klasy i dziedziczenie
  • Obsługę wyjątków
  • Wyrażenia lambda
  • Operacje wejścia-wyjścia
  • Projektowanie orientowane obiektowo
  • Szablony

Spis treści

0. Proszę tego nie czytać! (1)

  • 0.1. Zaprzyjaźnijmy się! (1)

1. Startujemy! (8)

  • 1.1. Pierwszy program (8)
  • 1.2. Drugi program (13)
  • 1.3. Ćwiczenia (18)

2. Instrukcje sterujące (20)

  • 2.1. Prawda - fałsz, czyli o warunkach (20)
    • 2.1.1. Wyrażenie logiczne (20)
    • 2.1.2. Zmienna logiczna bool w roli warunku (21)
    • 2.1.3. Stare dobre sposoby z dawnego C++ (21)
  • 2.2. Instrukcja warunkowa if (22)
  • 2.3. Pętla while (26)
  • 2.4. Pętla do...while. (27)
  • 2.5. Pętla for (28)
  • 2.6. Instrukcja switch (31)
  • 2.7. Co wybrać: switch czy if...else? (33)
  • 2.8. Instrukcja break (36)
  • 2.9. Instrukcja goto (37)
  • 2.10. Instrukcja continue (39)
  • 2.11. Klamry w instrukcjach sterujących (40)
  • 2.12. Ćwiczenia (41)

3. Typy (44)

  • 3.1. Deklaracje typu (44)
  • 3.2. Systematyka typów z języka C++ (45)
  • 3.3. Typy fundamentalne (46)
    • 3.3.1. Typy przeznaczone do pracy z liczbami całkowitymi (46)
    • 3.3.2. Typy do przechowywania znaków alfanumerycznych (47)
    • 3.3.3. Typy reprezentujące liczby zmiennoprzecinkowe (47)
    • 3.3.4. bool - typ do reprezentacji obiektów logicznych (48)
    • 3.3.5. Kwestia dokładności (49)
    • 3.3.6. Jak poznać limity (ograniczenia) typów wbudowanych (51)
  • 3.4. Typy o precyzyjnie żądanej szerokości (55)
  • 3.5. InicjaLIZAcja, czyli nadanie wartości w momencie narodzin (59)
  • 3.6. Definiowanie obiektów "w biegu" (60)
  • 3.7. Stałe dosłowne (62)
    • 3.7.1. Stałe dosłowne typu bool (63)
    • 3.7.2. Stałe będące liczbami całkowitymi (63)
    • 3.7.3. Stałe reprezentujące liczby zmiennoprzecinkowe (66)
    • 3.7.4. Stała dosłowna nullptr - dla wskaźników (67)
    • 3.7.5. Stałe znakowe (68)
    • 3.7.6. Stałe tekstowe, napisy, albo po prostu stringi (71)
    • 3.7.7. Surowe stałe tekstowe (napisy, stringi) (73)
  • 3.8. Typy złożone (76)
  • 3.9. Typ void (77)
  • 3.10. Zakres ważności nazwy obiektu a czas życia obiektu (78)
    • 3.10.1. Zakres: lokalny (78)
    • 3.10.2. Zakres: instrukcja (79)
    • 3.10.3. Zakres: blok funkcji (79)
    • 3.10.4. Zakres: obszar pliku (80)
    • 3.10.5. Zakres: obszar klasy (80)
    • 3.10.6. Zakres określony przez przestrzeń nazw (80)
  • 3.11. Zasłanianie nazw (85)
  • 3.12. Specyfikator (przydomek) const (87)
  • 3.13. Specyfikator (przydomek) constexpr (88)
  • 3.14. Obiekty register (92)
  • 3.15. Specyfikator volatile (92)
  • 3.16. using oraz typedef - tworzenie dodatkowej nazwy typu (93)
  • 3.17. Typy wyliczeniowe enum (96)
    • 3.17.1. Dawne zwykłe enum a nowe zakresowe enum class (103)
    • 3.17.2. Kilka uwag dla wtajemniczonych (105)
  • 3.18. auto, czyli automatyczne rozpoznawanie typu definiowanego obiektu (106)
  • 3.19. decltype - operator do określania typu zadanego wyrażenia (109)
  • 3.20. Inicjalizacja z pustą klamrą { }, czyli wartością domniemaną (111)
  • 3.21. Przydomek alignas - adresy równe i równiejsze (113)
  • 3.22. Ćwiczenia (115)

4. Operatory (119)

  • 4.1. Operatory arytmetyczne (119)
    • 4.1.1. Operator %, czyli reszta z dzielenia (modulo) (120)
    • 4.1.2. Jednoargumentowe operatory + i (121)
    • 4.1.3. Operatory inkrementacji i dekrementacji (121)
    • 4.1.4. Operator przypisania = (123)
  • 4.2. Operatory logiczne (124)
    • 4.2.1. Operatory relacji (124)
    • 4.2.2. Operatory sumy logicznej || oraz iloczynu logicznego && (125)
    • 4.2.3. Wykrzyknik !, czyli operator negacji (126)
  • 4.3. Operatory bitowe (127)
    • 4.3.1. Przesunięcie w lewo << (128)
    • 4.3.2. Przesunięcie w prawo >> (129)
    • 4.3.3. Bitowe operatory sumy, iloczynu, negacji, różnicy symetrycznej (130)
  • 4.4. Różnica między operatorami logicznymi a operatorami bitowymi (130)
  • 4.5. Pozostałe operatory przypisania (132)
  • 4.6. Operator uzyskiwania adresu (operator &) (133)
  • 4.7. Wyrażenie warunkowe (134)
  • 4.8. Operator sizeof (135)
  • 4.9. Operator noexcept (137)
  • 4.10. Deklaracja static_assert (137)
  • 4.11. Operator alignof informujący o najkorzystniejszym wyrównaniu adresu (139)
  • 4.12. Operatory rzutowania (141)
    • 4.12.1. Rzutowanie według tradycyjnych (niezalecanych) sposobów (141)
    • 4.12.2. Rzutowanie za pomocą nowych operatorów rzutowania (142)
    • 4.12.3. Operator static_cast (143)
    • 4.12.4. Operator const_cast (145)
    • 4.12.5. Operator dynamic_cast (146)
    • 4.12.6. Operator reinterpret_cast (147)
  • 4.13. Operator: przecinek (148)
  • 4.14. Priorytety operatorów (148)
  • 4.15. Łączność operatorów (151)
  • 4.16. Ćwiczenia (152)

5. Typ string i typ vector - pierwsza wzmianka (156)

  • 5.1. Typ std::string do pracy z tekstami (156)
  • 5.2. Typ vector - długi rząd obiektów (161)
  • 5.3. Zakresowe for (169)
  • 5.4. Ćwiczenia (172)

6. Funkcje (174)

  • 6.1. Definicja funkcji i jej wywołanie (174)
  • 6.2. Deklaracja funkcji (175)
  • 6.3. Funkcja często wywołuje inną funkcję (177)
  • 6.4. Zwracanie przez funkcję rezultatu (177)
    • 6.4.1. Obiekt tworzony za pomocą auto, a inicjalizowany rezultatem funkcji (179)
    • 6.4.2. O zwracaniu (lub niezwracaniu) rezultatu przez funkcję main (180)
  • 6.5. Nowy, alternatywny sposób deklaracji funkcji (181)
  • 6.6. Stos (183)
  • 6.7. Przesyłanie argumentów do funkcji przez wartość (184)
  • 6.8. Przesyłanie argumentów przez referencję (185)
  • 6.9. Pożyteczne określenia: l-wartość i r-wartość (188)
  • 6.10. Referencje do l-wartości i referencje do r-wartości jako argumenty funkcji (190)
    • 6.10.1. Który sposób przesyłania argumentu do funkcji wybrać? (197)
  • 6.11. Kiedy deklaracja funkcji nie jest konieczna? (198)
  • 6.12. Argumenty domniemane (199)
    • 6.12.1. Ciekawostki na temat argumentów domniemanych (202)
  • 6.13. Nienazwany argument (207)
  • 6.14. Funkcje inline (w linii) (208)
  • 6.15. Przypomnienie o zakresie ważności nazw deklarowanych wewnątrz funkcji (212)
  • 6.16. Wybór zakresu ważności nazwy i czasu życia obiektu (212)
    • 6.16.1. Obiekty globalne (212)
    • 6.16.2. Obiekty automatyczne (213)
    • 6.16.3. Obiekty lokalne statyczne (214)
  • 6.17. Funkcje w programie składającym się z kilku plików (218)
    • 6.17.1. Nazwy statyczne globalne (222)
  • 6.18. Funkcja zwracająca rezultat będący referencją l-wartości (223)
  • 6.19. Funkcje rekurencyjne (228)
  • 6.20. Funkcje biblioteczne (237)
  • 6.21. Funkcje constexpr (240)
    • 6.21.1. Wymogi, które musi spełniać funkcja constexpr (w standardzie C++11) (242)
    • 6.21.2. Przykład pokazujący aspekty funkcji constexpr (243)
    • 6.21.3. Argumenty funkcji constexpr będące referencjami (252)
  • 6.22. Definiowanie referencji przy użyciu słowa auto (253)
    • 6.22.1. Gdy inicjalizatorem jest wywołanie funkcji zwracającej referencję (260)
  • 6.23. Ćwiczenia (263)

7. Preprocesor (269)

  • 7.1. Dyrektywa pusta # (269)
  • 7.2. Dyrektywa #define (269)
  • 7.3. Dyrektywa #undef (271)
  • 7.4. Makrodefinicje (272)
  • 7.5. Sklejacz nazw argumentów, czyli operator ## (274)
  • 7.6. Parametr aktualny makrodefinicji - w postaci tekstu (275)
  • 7.7. Dyrektywy kompilacji warunkowej (275)
  • 7.8. Dyrektywa #error (279)
  • 7.9. Dyrektywa #line (280)
  • 7.10. Wstawianie treści innych plików do tekstu kompilowanego właśnie pliku (280)
  • 7.11. Dyrektywy zależne od implementacji (282)
  • 7.12. Nazwy predefiniowane (282)
  • 7.13. Ćwiczenia (285)

8. Tablice (288)

  • 8.1. Co to jest tablica (288)
  • 8.2. Elementy tablicy (289)
  • 8.3. Inicjalizacja tablic (291)
  • 8.4. Przekazywanie tablicy do funkcji (292)
  • 8.5. Przykład z tablicą elementów typu enum (296)
  • 8.6. Tablice znakowe (298)
  • 8.7. Ćwiczenia (306)

9. Tablice wielowymiarowe (311)

  • 9.1. Tablica tablic (311)
  • 9.2. Przykład programu pracującego z tablicą dwuwymiarową (313)
  • 9.3. Gdzie w pamięci jest dany element tablicy (315)
  • 9.4. Typ wyrażeń związanych z tablicą wielowymiarową (315)
  • 9.5. Przesyłanie tablic wielowymiarowych do funkcji (317)
  • 9.6. Ćwiczenia (319)

10. Wektory wielowymiarowe (321)

  • 10.1. Najpierw przypomnienie istotnych tu cech klasy vector (321)
  • 10.2. Jak za pomocą klasy vector budować tablice wielowymiarowe (322)
  • 10.3. Funkcja pokazująca zawartość wektora dwuwymiarowego (323)
  • 10.4. Definicja dwuwymiarowego wektora - pustego (325)
  • 10.5. Definicja wektora dwuwymiarowego z listą inicjalizatorów (326)
  • 10.6. Wektor dwuwymiarowy o żądanych rozmiarach, choć bez inicjalizacji (327)
  • 10.7. Zmiana rozmiaru wektora 2D funkcją resize (328)
  • 10.8. Zmiany rozmiaru wektora 2D funkcjami push_back, pop_back (329)
  • 10.9. Zmniejszanie rozmiaru wektora dwuwymiarowego funkcją pop_back (332)
  • 10.10. Funkcje mogące modyfikować treść wektora 2D (332)
  • 10.11. Wysłanie rzędu wektora 2D do funkcji pracującej z wektorem 1D (334)
  • 10.12. Całość przykładu definiującego wektory dwuwymiarowe (335)
  • 10.13. Po co są dwuwymiarowe wektory nieprostokątne (335)
  • 10.14. Wektory trójwymiarowe (337)
  • 10.15. Sposoby definicji wektora 3D o ustalonych rozmiarach (340)
  • 10.16. Nadawanie pustemu wektorowi 3D wymaganych rozmiarów (344)
    • 10.16.1. Zmiana rozmiarów wektora 3D funkcjami resize (344)
    • 10.16.2. Zmiana rozmiarów wektora 3D funkcjami push_back (346)
  • 10.17. Trójwymiarowe wektory 3D - nieprostopadłościenne (347)
  • 10.18. Ćwiczenia (351)

11. Wskaźniki - wiadomości wstępne (353)

  • 11.1. Wskaźniki mogą bardzo ułatwić życie (353)
  • 11.2. Definiowanie wskaźników (355)
  • 11.3. Praca ze wskaźnikiem (356)
  • 11.4. Definiowanie wskaźnika z użyciem auto (359)
  • 11.5. Wyrażenie *wskaźnik jest l-wartością (360)
  • 11.6. Operator rzutowania reinterpret_cast a wskaźniki (360)
  • 11.7. Wskaźniki typu void* (363)
  • 11.8. Strzał na oślep - wskaźnik zawsze na coś wskazuje (365)
    • 11.8.1. Wskaźnik wolno porównać z adresem zero - nullptr (367)
  • 11.9. Ćwiczenia (367)

12. Cztery domeny zastosowania wskaźników (369)

  • 12.1. Zastosowanie wskaźników wobec tablic (369)
    • 12.1.1. Ćwiczenia z mechaniki ruchu wskaźnika (369)
    • 12.1.2. Użycie wskaźnika w pracy z tablicą (373)
    • 12.1.3. Arytmetyka wskaźników (377)
    • 12.1.4. Porównywanie wskaźników (379)
  • 12.2. Zastosowanie wskaźników w argumentach funkcji (380)
    • 12.2.1. Jeszcze raz o przesyłaniu tablic do funkcji (384)
    • 12.2.2. Odbieranie tablicy jako wskaźnika (384)
    • 12.2.3. Argument formalny będący wskaźnikiem do obiektu const (386)
  • 12.3. Zastosowanie wskaźników przy dostępie do konkretnych komórek pamięci (389)
  • 12.4. Rezerwacja obszarów pamięci (390)
    • 12.4.1. Operatory new i delete albo Oratorium Stworzenie Świata (391)
    • 12.4.2. Operator new a słowo kluczowe auto (395)
    • 12.4.3. Inicjalizacja obiektu tworzonego operatorem new (395)
    • 12.4.4. Operatorem new możemy także tworzyć obiekty stałe (396)
    • 12.4.5. Dynamiczna alokacja tablicy (397)
    • 12.4.6. Tablice wielowymiarowe tworzone operatorem new (398)
    • 12.4.7. Umiejscawiający operator new (401)
    • 12.4.8. "Przychodzimy, odchodzimy - cichuteńko, na..." (406)
    • 12.4.9. Zapas pamięci to nie studnia bez dna (408)
    • 12.4.10. Nowy sposób powiadomienia: rzucenie wyjątku std::bad_alloc (409)
    • 12.4.11. Funkcja set_new_handler (411)
  • 12.5. Ćwiczenia (413)

13. Wskaźniki - runda trzecia (417)

  • 13.1. Stałe wskaźniki (417)
  • 13.2. Stałe wskaźniki a wskaźniki do stałych (418)
    • 13.2.1. Wierzch i głębia (419)
  • 13.3. Definiowanie wskaźnika z użyciem auto (420)
    • 13.3.1. Symbol zastępczy auto a opuszczanie gwiazdki przy definiowaniu wskaźnika (423)
  • 13.4. Sposoby ustawiania wskaźników (425)
  • 13.5. Parada kłamców, czyli o rzutowaniu const_cast (427)
  • 13.6. Tablice wskaźników (431)
  • 13.7. Wariacje na temat C-stringów (433)
  • 13.8. Argumenty z linii wywołania programu (440)
  • 13.9. Ćwiczenia (443)

14. Wskaźniki do funkcji (445)

  • 14.1. Wskaźnik, który może wskazywać na funkcję (445)
  • 14.2. Ćwiczenia z definiowania wskaźników do funkcji (448)
  • 14.3. Wskaźnik do funkcji jako argument innej funkcji (454)
  • 14.4. Tablica wskaźników do funkcji (458)
  • 14.5. Użycie deklaracji using i typedef w świecie wskaźników (463)
    • 14.5.1. Alias przydatny w argumencie funkcji (463)
    • 14.5.2. Alias przydatny w definicji tablicy wskaźników do funkcji (464)
  • 14.6. Użycie auto lub decltype do automatycznego rozpoznania potrzebnego typu (465)
  • 14.7. Ćwiczenia (467)

15. Przeładowanie nazwy funkcji (469)

  • 15.1. Co oznacza przeładowanie (469)
  • 15.2. Przeładowanie od kuchni (472)
  • 15.3. Jak możemy przeładowywać, a jak się nie da? (472)
  • 15.4. Czy przeładowanie nazw funkcji jest techniką orientowaną obiektowo? (475)
  • 15.5. Linkowanie z modułami z innych języków (476)
  • 15.6. Przeładowanie a zakres ważności deklaracji funkcji (477)
  • 15.7. Rozważania o identyczności lub odmienności typów argumentów (479)
    • 15.7.1. Przeładowanie a typy tworzone z using lub typedef oraz typy enum (480)
    • 15.7.2. Tablica a wskaźnik (480)
    • 15.7.3. Pewne szczegóły o tablicach wielowymiarowych (481)
    • 15.7.4. Przeładowanie a referencja (483)
    • 15.7.5. Identyczność typów: T, const T, volatile T (484)
    • 15.7.6. Przeładowanie a typy: T*, volatile T*, const T* (485)
    • 15.7.7. Przeładowanie a typy: T&, volatile T&, const T& (486)
  • 15.8. Adres funkcji przeładowanej (487)
    • 15.8.1. Zwrot rezultatu będącego adresem funkcji przeładowanej (489)
  • 15.9. Kulisy dopasowywania argumentów do funkcji przeładowanych (491)
  • 15.10. Etapy dopasowania (492)
    • 15.10.1. Etap 1. Dopasowanie dokładne, bo konwersja niepotrzebna (492)
    • 15.10.2. Etap 1a. Dopasowanie dokładne, bo z tzw. trywialną konwersją (493)
    • 15.10.3. Etap 2. Dopasowanie z awansem (z promocją) (494)
    • 15.10.4. Etap 3. Próba dopasowania za pomocą konwersji standardowych (496)
    • 15.10.5. Etap 4. Dopasowanie z użyciem konwersji zdefiniowanych przez użytkownika (498)
    • 15.10.6. Etap 5. Dopasowanie do funkcji z wielokropkiem (498)
  • 15.11. Wskaźników nie dopasowuje się inaczej niż dosłownie (498)
  • 15.12. Dopasowywanie wywołań z kilkoma argumentami (499)
  • 15.13. Ćwiczenia (500)

16. Klasy (503)

  • 16.1. Typy definiowane przez użytkownika (503)
  • 16.2. Składniki klasy (505)
  • 16.3. Składnik będący obiektem (506)
  • 16.4. Kapsułowanie (507)
  • 16.5. Ukrywanie informacji (508)
  • 16.6. Klasa a obiekt (511)
  • 16.7. Wartości wstępne w składnikach nowych obiektów. Inicjalizacja "w klasie" (513)
  • 16.8. Funkcje składowe (516)
    • 16.8.1. Posługiwanie się funkcjami składowymi (516)
    • 16.8.2. Definiowanie funkcji składowych (517)
  • 16.9. Jak to właściwie jest? (this) (522)
  • 16.10. Odwołanie się do publicznych danych składowych obiektu (524)
  • 16.11. Zasłanianie nazw (525)
    • 16.11.1. Nie sięgaj z klasy do obiektów globalnych (528)
  • 16.12. Przeładowanie i zasłonięcie równocześnie (529)
  • 16.13. Nowa klasa? Osobny plik! (529)
    • 16.13.1. Poznajmy praktyczną realizację wieloplikowego programu (532)
    • 16.13.2. Zasada umieszczania dyrektywy using namespace w plikach (544)
  • 16.14. Przesyłanie do funkcji argumentów będących obiektami (544)
    • 16.14.1. Przesyłanie obiektu przez wartość (544)
    • 16.14.2. Przesyłanie przez referencję (546)
  • 16.15. Konstruktor - pierwsza wzmianka (547)
  • 16.16. Destruktor - pierwsza wzmianka (552)
  • 16.17. Składnik statyczny (556)
    • 16.17.1. Do czego może się przydać składnik statyczny w klasie? (565)
  • 16.18. Statyczna funkcja składowa (565)
    • 16.18.1. Deklaracja składnika statycznego mająca inicjalizację "w klasie" (570)
  • 16.19. Funkcje składowe typu const oraz volatile (576)
    • 16.19.1. Przeładowanie a funkcje składowe const i volatile (580)
  • 16.20. Struktura (580)
  • 16.21. Klasa będąca agregatem. Klasa bez konstruktora (581)
  • 16.22. Funkcje składowe z przydomkiem constexpr (583)
  • 16.23. Specyfikator mutable (590)
  • 16.24. Bardziej rozbudowany przykład zastosowania klasy (591)
  • 16.25. Ćwiczenia (602)

17. Biblioteczna klasa std::string (607)

  • 17.1. Rozwiązanie przechowywania tekstów musiało się znaleźć (607)
  • 17.2. Klasa std::string to przecież nasz stary znajomy (609)
  • 17.3. Definiowanie obiektów klasy string (610)
  • 17.4. Użycie operatorów =, +, += w pracy ze stringami (615)
  • 17.5. Pojemność, rozmiar i długość stringu (616)
    • 17.5.1. Bliźniacze funkcje size() i length() (616)
    • 17.5.2. Funkcja składowa empty (617)
    • 17.5.3. Funkcja składowa max_size (617)
    • 17.5.4. Funkcja składowa capacity (617)
    • 17.5.5. Funkcje składowe reserve i shrink_to_fit (619)
    • 17.5.6. resize - zmiana długości stringu "na siłę" (620)
    • 17.5.7. Funkcja składowa clear (622)
  • 17.6. Użycie operatora [ \ oraz funkcji at (622)
    • 17.6.1. Działanie operatora [ \ (623)
    • 17.6.2. Działanie funkcji składowej at (624)
    • 17.6.3. Przebieganie po wszystkich literach stringu zakresowym for (627)
  • 17.7. Funkcje składowe front i back (627)
  • 17.8. Jak umieścić w tekście liczbę? (628)
  • 17.9. Jak wczytać liczbę ze stringu? (630)
  • 17.10. Praca z fragmentem stringu, czyli z substringiem (633)
  • 17.11. Funkcja składowa substr (634)
  • 17.12. Szukanie zadanego substringu w obiekcie klasy string - funkcje find (635)
  • 17.13. Szukanie rozpoczynane od końca stringu (638)
  • 17.14. Szukanie w stringu jednego ze znaków z zadanego zestawu (639)
  • 17.15. Usuwanie znaków ze stringu - erase i pop_back (641)
  • 17.16. Wstawianie znaków do istniejącego stringu - funkcje insert (642)
  • 17.17. Zamiana części znaków na inne znaki - replace (644)
  • 17.18. Zaglądanie do wnętrza obiektu klasy string funkcją data (647)
  • 17.19. Zawartość obiektu klasy string a C-string (648)
  • 17.20. W porządku alfabetycznym, czyli porównywanie stringów (651)
    • 17.20.1. Porównywanie stringów za pomocą funkcji compare (652)
    • 17.20.2. Porównywanie stringów przy użyciu operatorów ==, !=, <, >, <=, >= (656)
  • 17.21. Zamiana treści stringu na małe lub wielkie litery (657)
  • 17.22. Kopiowanie treści obiektu klasy string do tablicy znakowej - funkcja copy (659)
  • 17.23. Wzajemna zamiana treści dwóch obiektów klasy string - funkcja swap (660)
  • 17.24. Wczytywanie z klawiatury stringu o nieznanej wcześniej długości - getline (661)
    • 17.24.1. Pułapka, czyli jak getline może Cię zaskoczyć (664)
  • 17.25. Iteratory stringu (668)
    • 17.25.1. Iterator do obiektu stałego (672)
    • 17.25.2. Funkcje składowe klasy string pracujące z iteratorami (673)
  • 17.26. Klasa string korzysta z techniki przenoszenia (678)
  • 17.27. Bryk, czyli "pamięć zewnętrzna" programisty (679)
  • 17.28. Ćwiczenia (687)

18. Deklaracje przyjaźni (694)

  • 18.1. Przyjaciele w życiu i w C++ (694)
  • 18.2. Przykład: dwie klasy deklarują przyjaźń z tą samą funkcją (696)
  • 18.3. W przyjaźni trzeba pamiętać o kilku sprawach (698)
  • 18.4. Obdarzenie przyjaźnią funkcji składowej innej klasy (701)
  • 18.5. Klasy zaprzyjaźnione (703)
  • 18.6. Konwencja umieszczania deklaracji przyjaźni w klasie (705)
  • 18.7. Kilka otrzeźwiających słów na zakończenie (705)
  • 18.8. Ćwiczenia (706)

19. Obsługa sytuacji wyjątkowych (708)

  • 19.1. Jak dać znać, że coś się nie udało? (708)
  • 19.2. Pierwszy prosty przykład (710)
  • 19.3. Kolejność bloków catch ma znaczenie (712)
  • 19.4. Który blok catch nadaje się do złapania lecącego wyjątku? (713)
  • 19.5. Bloki try mogą być zagnieżdżane (715)
  • 19.6. Obsługa wyjątków w praktycznym programie (718)
  • 19.7. Specyfikator noexcept i operator noexcept (729)
  • 19.8. Ćwiczenia (732)

20. Klasa-składnik oraz klasa lokalna (734)

  • 20.1. Klasa-składnik, czyli gdy w klasie jest zagnieżdżona definicja innej klasy (734)
  • 20.2. Prawdziwy przykład zagnieżdżenia definicji klasy (741)
  • 20.3. Lokalna definicja klasy (752)
  • 20.4. Lokalne nazwy typów (755)
  • 20.5. Ćwiczenia (756)

21. Konstruktory i destruktory (758)

  • 21.1. Konstruktor (758)
    • 21.1.1. Przykład programu zawierającego klasę z konstruktorami (759)
  • 21.2. Specyfikator (przydomek) explicit (770)
  • 21.3. Kiedy i jak wywoływany jest konstruktor (771)
    • 21.3.1. Konstruowanie obiektów lokalnych (771)
    • 21.3.2. Konstruowanie obiektów globalnych (772)
    • 21.3.3. Konstrukcja obiektów tworzonych operatorem new (772)
    • 21.3.4. Jawne wywołanie konstruktora (773)
    • 21.3.5. Dalsze sytuacje, gdy pracuje konstruktor (776)
  • 21.4. Destruktor (776)
    • 21.4.1. Jawne wywołanie destruktora (ogromnie rzadka sytuacja) (778)
  • 21.5. Nie rzucajcie wyjątków z destruktorów (778)
  • 21.6. Konstruktor domniemany (780)
  • 21.7. Funkcje składowe z przypiskami = default i = delete (781)
  • 21.8. Konstruktorowa lista inicjalizacyjna składników klasy (783)
    • 21.8.1. Dla wtajemniczonych: wyjątki rzucane z konstruktorowej listy inicjalizacyjnej (790)
  • 21.9. Konstruktor delegujący (794)
  • 21.10. Pomocnicza klasa std::initializer_list - lista inicjalizatorów (801)
    • 21.10.1. Zastosowania niekonstruktorowe (801)
    • 21.10.2. Konfuzja: lista inicjalizatorów a lista inicjalizacyjna (810)
    • 21.10.3. Konstruktor z argumentem będącym klamrową listą inicjalizatorów (811)
  • 21.11. Konstrukcja obiektu, którego składnikiem jest obiekt innej klasy (816)
  • 21.12. Konstruktory niepubliczne? (823)
  • 21.13. Konstruktory constexpr mogą wytwarzać obiekty constexpr (825)
  • 21.14. Ćwiczenia (835)

22. Konstruktory: kopiujący i przenoszący (838)

  • 22.1. Konstruktor kopiujący (albo inicjalizator kopiujący) (838)
  • 22.2. Przykład klasy z konstruktorem kopiującym (839)
  • 22.3. Kompilatorowi wolno pominąć niepotrzebne kopiowanie (844)
  • 22.4. Dlaczego przez referencję? (846)
  • 22.5. Konstruktor kopiujący gwarantujący nietykalność (847)
  • 22.6. Współodpowiedzialność (848)
  • 22.7. Konstruktor kopiujący generowany automatycznie (848)
  • 22.8. Kiedy powinniśmy sami zdefiniować konstruktor kopiujący? (849)
  • 22.9. Referencja do r-wartości daje zezwolenie na recykling (856)
  • 22.10. Funkcja std::move, która nie przenosi, a tylko rzutuje (859)
  • 22.11. Odebrana r-wartość staje się w ciele funkcji l-wartością (861)
  • 22.12. Konstruktor przenoszący (inicjalizator przenoszący) (863)
    • 22.12.1. Konstruktor przenoszący generowany przez kompilator (868)
    • 22.12.2. Inne konstruktory generowane automatycznie (868)
    • 22.12.3. Zwrot obiektu lokalnego przez wartość? Nie używamy przenoszenia! (869)
  • 22.13. Tak zwana "semantyka przenoszenia" (870)
  • 22.14. Nowe pojęcia dla ambitnych: gl-wartość, x-wartość i pr-wartość (870)
  • 22.15. decltype - operator rozpoznawania typu bardzo wyszukanych wyrażeń (873)
  • 22.16. Ćwiczenia (878)

23. Tablice obiektów (880)

  • 23.1. Definiowanie tablic obiektów i praca z nimi (880)
  • 23.2. Tablica obiektów definiowana operatorem new (881)
  • 23.3. Inicjalizacja tablic obiektów (883)
    • 23.3.1. Inicjalizacja tablicy, której obiekty są agregatami (883)
    • 23.3.2. Inicjalizacja tablic, których elementy nie są agregatami (886)
  • 23.4. Wektory obiektów (890)
    • 23.4.1. Wektor, którego elementami są obiekty klasy będącej agregatem (892)
    • 23.4.2. Wektor, którego elementami są obiekty klasy niebędącej agregatem (894)
  • 23.5. Ćwiczenia (895)

24. Wskaźnik do składników klasy (896)

  • 24.1. Wskaźniki zwykłe - repetytorium (896)
  • 24.2. Wskaźnik do pokazywania na składnik-daną (897)
    • 24.2.1. Przykład zastosowania wskaźników do składników klasy (901)
  • 24.3. Wskaźnik do funkcji składowej (908)
    • 24.3.1. Przykład zastosowania wskaźników do funkcji składowych (910)
  • 24.4. Tablica wskaźników do danych składowych klasy (917)
  • 24.5. Tablica wskaźników do funkcji składowych klasy (918)
    • 24.5.1. Przykład tablicy/wektora wskaźników do funkcji składowych (919)
  • 24.6. Wskaźniki do składników statycznych są zwykłe (922)
  • 24.7. Ćwiczenia (923)

25. Konwersje definiowane przez użytkownika (925)

  • 25.1. Sformułowanie problemu (925)
  • 25.2. Konstruktory konwertujące (927)
    • 25.2.1. Kiedy jawnie, kiedy niejawnie (928)
    • 25.2.2. Przykład konwersji konstruktorem (933)
  • 25.3. Funkcja konwertująca - operator konwersji (935)
    • 25.3.1. Na co funkcja konwertująca zamieniać nie może (941)
  • 25.4. Który wariant konwersji wybrać? (942)
  • 25.5. Sytuacje, w których zachodzi konwersja (944)
  • 25.6. Zapis jawnego wywołania konwersji typów (945)
    • 25.6.1. Advocatus zapisu przypominającego: "wywołanie funkcji" (945)
    • 25.6.2. Advocatus zapisu: "rzutowanie" (946)
  • 25.7. Nie całkiem pasujące argumenty, czyli konwersje kompilatora przy dopasowaniu (946)
  • 25.8. Kilka rad dotyczących konwersji (951)
  • 25.9. Ćwiczenia (952)

26. Przeładowanie operatorów (954)

  • 26.1. Co to znaczy przeładować operator? (954)
  • 26.2. Przeładowanie operatorów - definicja i trochę teorii (956)
  • 26.3. Moje zabawki (960)
  • 26.4. Funkcja operatorowa jako funkcja składowa (961)
  • 26.5. Funkcja operatorowa nie musi być przyjacielem klasy (964)
  • 26.6. Operatory predefiniowane (964)
  • 26.7. Ile operandów ma mieć ten operator? (965)
  • 26.8. Operatory jednooperandowe (965)
  • 26.9. Operatory dwuoperandowe (968)
    • 26.9.1. Przykład na przeładowanie operatora dwuoperandowego (968)
    • 26.9.2. Przemienność (970)
    • 26.9.3. Choć operatory inne, to nazwę mają tę samą...
Kategoria: Programowanie
Zabezpieczenie: Watermark
Watermark
Watermarkowanie polega na znakowaniu plików wewnątrz treści, dzięki czemu możliwe jest rozpoznanie unikatowej licencji transakcyjnej Użytkownika. E-książki zabezpieczone watermarkiem można odczytywać na wszystkich urządzeniach odtwarzających wybrany format (czytniki, tablety, smartfony). Nie ma również ograniczeń liczby licencji oraz istnieje możliwość swobodnego przenoszenia plików między urządzeniami. Pliki z watermarkiem są kompatybilne z popularnymi programami do odczytywania ebooków, jak np. Calibre oraz aplikacjami na urządzenia mobilne na takie platformy jak iOS oraz Android.
ISBN: 978-83-8322-412-1
Rozmiar pliku: 13 MB

BESTSELLERY

Kategorie: