Język C++. Gotowe rozwiązania dla programistów Matthew Wilson

Dostępność produktu

Produkt nie został jeszcze oceniony pod kątem ułatwień dostępu lub nie podano żadnych informacji o ułatwieniach dostępu lub są one niewystarczające. Prawdopodobnie Wydawca/Dostawca jeszcze nie umożliwił dokonania walidacji produktu lub nie przekazał odpowiednich informacji na temat jego dostępności.

Spis treści książki

Przedmowa (11)


Prolog. Filozofia praktyka niedoskonałego (19)


Niedoskonałości, ograniczenia, definicje i zalecenia (29)


Część I Podstawy (37)


Rozdział 1. Wymuszanie założeń projektowych: ograniczenia, kontrakty i asercje (39)


• 1.1. Kilka oczywistych mądrości (40)
  
• 1.2. Kontrakty kompilacji - ograniczenia (41)
  
• 1.3. Kontrakty wykonawcze: warunki wejściowe, końcowe i niezmienniki (49)
  
• 1.4. Asercje (56)

Rozdział 2. Życie obiektów (67)


• 2.1. Cykl życia obiektu (67)
  
• 2.2. Kontrola klientów (68)
  
• 2.3. Dobrodziejstwa list inicjalizacji (73)

Rozdział 3. Hermetyzacja zasobów (81)


• 3.1. Poziomy hermetyzacji zasobów (81)
  
• 3.2. Typy POD (82)
  
• 3.3. Pośrednie typy opakowujące (84)
  
• 3.4. Typy RRID (87)
  
• 3.5. Typy RAII (92)
  
• 3.6. RAII - podsumowanie (95)

Rozdział 4. Hermetyzacja danych i typy wartości (97)


• 4.1. Poziomy hermetyzacji danych (98)
  
• 4.2. Typy wartości a typy egzystencjalne (98)
  
• 4.3. Klasyfikacja typów wartości (99)
  
• 4.4. Typy otwarte (101)
  
• 4.5. Typy hermetyzowane (103)
  
• 4.6. Typy wartości (104)
  
• 4.7. Arytmetyczne typy wartości (106)
  
• 4.8. Typy wartości - podsumowanie (107)
  
• 4.9. Hermetyzacja - podsumowanie (107)

Rozdział 5. Modele dostępu do obiektów (113)


• 5.1. Gwarantowany czas życia (113)
  
• 5.2. Kopia dla wywołującego (115)
  
• 5.3. Oryginał dla wywołującego (116)
  
• 5.4. Obiekty współdzielone (116)

Rozdział 6. Zasięg klas (119)


• 6.1. Wartość (119)
  
• 6.2. Stan (124)
  
• 6.3. API i usługi (128)
  
• 6.4. Mechanizmy języka (132)

Część II Przetrwanie w świecie rzeczywistym (135)


Rozdział 7. ABI (137)


• 7.1. Udostępnianie kodu (137)
  
• 7.2. Wymagania ABI C (139)
  
• 7.3. Wymagania ABI C++ (144)
  
• 7.4. C - i wszystko jasne (148)

Rozdział 8. Obiekty bez granic (157)


• 8.1. Czyżby przenośne tabele funkcji wirtualnych? (157)
  
• 8.2. Przenośne tabele vtable (161)
  
• 8.3. Przenośność - podsumowanie (169)

Rozdział 9. Biblioteki dynamiczne (171)


• 9.1. Jawne wywołania funkcji (171)
  
• 9.2. Tożsamość - jednostki i przestrzeń konsolidacji (174)
  
• 9.3. Czas życia (175)
  
• 9.4. Wersjonowanie (176)
  
• 9.5. Własność zasobów (179)
  
• 9.6. Biblioteki dynamiczne - podsumowanie (180)

Rozdział 10. Wątki (181)


• 10.1. Synchronizacja dostępu do wartości całkowitych (182)
  
• 10.2. Synchronizacja dostępu do bloków kodu - regiony krytyczne (186)
  
• 10.3. Wydajność operacji atomowych (190)
  
• 10.4. Rozszerzenia wielowątkowe (195)
  
• 10.5. TSS - składowanie danych w wątkach (199)

Rozdział 11. Obiekty statyczne (207)


• 11.1. Globalne obiekty statyczne (209)
  
• 11.2. Singletony (214)
  
• 11.3. Lokalne obiekty statyczne funkcji (222)
  
• 11.4. Składowe statyczne (224)
  
• 11.5. Obiekty statyczne - podsumowanie (227)

Rozdział 12. Optymalizacja (229)


• 12.1. Funkcje inline (229)
  
• 12.2. Optymalizacja wartości zwracanej (231)
  
• 12.3. Optymalizacja pustych klas bazowych (234)
  
• 12.4. Optymalizacja pustych klas potomnych (237)
  
• 12.5. Zapobieganie optymalizacji (239)

Część III Kwestie językowe (243)


Rozdział 13. Typy podstawowe (245)


• 13.1. Komu bajt? (246)
  
• 13.2. Typy całkowitoliczbowe o stałym rozmiarze (249)
  
• 13.3. Duże typy całkowitoliczbowe (255)
  
• 13.4. Typy niebezpieczne (257)

Rozdział 14. Tablice i wskaźniki (263)


• 14.1. Nie powtarzaj się (263)
  
• 14.2. Degeneracja tablic do wskaźników (265)
  
• 14.3. dimensionof() (268)
  
• 14.4. Nie można przekazywać tablic do funkcji (270)
  
• 14.5. Tablice są zawsze przekazywane przez adres (273)
  
• 14.6. Tablice typów dziedziczonych (274)
  
• 14.7. Brak tablic wielowymiarowych (281)

Rozdział 15. Wartości (285)


• 15.1. NULL - słowo kluczowe, którego nie było (285)
  
• 15.2. Spadek do zera (292)
  
• 15.3. Naginanie prawdy (294)
  
• 15.4. Literały (296)
  
• 15.5. Stałe (302)

Rozdział 16. Słowa kluczowe (311)


• 16.1. interface (311)
  
• 16.2. temporary (314)
  
• 16.3. owner (317)
  
• 16.4. explicit(_cast) (321)
  
• 16.5. unique (326)
  
• 16.6. final (327)
  
• 16.7. Nieobsługiwane słowa kluczowe (328)

Rozdział 17. Składnia (331)


• 17.1. Układ klasy (331)
  
• 17.2. Wyrażenia warunkowe (334)
  
• 17.3. for (338)
  
• 17.4. Zapis zmiennych (341)

Rozdział 18. Definicja typów za pomocą typedef (345)


• 18.1. Definicje typu dla wskaźników (347)
  
• 18.2. Co wchodzi w skład definicji? (349)
  
• 18.3. Nowe nazwy (354)
  
• 18.4. Prawdziwe definicje typu (356)
  
• 18.5. Dobre, złe i brzydkie (361)

Część IV Świadome konwersje (369)


Rozdział 19. Rzutowanie (371)


• 19.1. Niejawna konwersja (371)
  
• 19.2. Rzutowanie w C++ (372)
  
• 19.3. Przypadek rzutowania w stylu C (373)
  
• 19.4. Rzutowanie na sterydach (375)
  
• 19.5. explicit_cast (377)
  
• 19.6. literal_cast (382)
  
• 19.7. union_cast (385)
  
• 19.8. comstl::interface_cast (388)
  
• 19.9. boost::polymorphic_cast (399)
  
• 19.10. Rzutowanie - podsumowanie (401)

Rozdział 20. Podkładki (403)


• 20.1. Ogarnąć zmiany i zwiększyć elastyczność (404)
  
• 20.2. Podkładki atrybutów (406)
  
• 20.3. Podkładki logiczne (408)
  
• 20.4. Podkładki sterujące (409)
  
• 20.5. Podkładki konwertujące (411)
  
• 20.6. Podkładki złożone (414)
  
• 20.7. Przestrzenie nazw a sprawdzenie Koeniga (420)
  
• 20.8. Dlaczego nie typy cechujące? (423)
  
• 20.9. Dopasowanie strukturalne (424)
  
• 20.10. Przełamywanie monolitu (426)
  
• 20.11. Podkładki - podsumowanie (428)

Rozdział 21. Forniry (429)


• 21.1. Lekkie RAII (430)
  
• 21.2. Wiązanie danych z operacjami (431)
  
• 21.3. Przypomnienie założeń (438)
  
• 21.4. Forniry - podsumowanie (440)

Rozdział 22. Sworznie (441)


• 22.1. Dodawanie nowej funkcjonalności (442)
  
• 22.2. Wybór skóry (442)
  
• 22.3. Przesłanianie metod niewirtualnych (443)
  
• 22.4. Wykorzystywanie zasięgu (445)
  
• 22.5. Symulowany polimorfizm czasu kompilacji - sworznie wsteczne (447)
  
• 22.6. Parametryzowalne pakowanie polimorficzne (449)
  
• 22.7. Sworznie - podsumowanie (451)

Rozdział 23. Konstruktory szablonów (453)


• 23.1. Ukryte koszty (455)
  
• 23.2. Wiszące referencje (455)
  
• 23.3. Specjalizacja konstruktorów szablonów (457)
  
• 23.4. Pośrednictwo argumentów (458)
  
• 23.5. Ukierunkowywanie na konkretne rodzaje argumentów (460)
  
• 23.6. Konstruktory szablonów - podsumowanie (461)

Część V Operatory (463)


Rozdział 24. operator bool() (465)


• 24.1. operator int() const (465)
  
• 24.2. operator void *() const (466)
  
• 24.3. operator bool() const (467)
  
• 24.4. operator !() - not! (468)
  
• 24.5. operator boolean const *() const (468)
  
• 24.6. operator int boolean::*() const (469)
  
• 24.7. Stosowanie operatorów w praktyce (469)
  
• 24.8. operator! (473)

Rozdział 25. Szybkie i nieinwazyjne łączenie ciągów znaków (475)


• 25.1. fast_string_concatenator<> (476)
  
• 25.2. Wydajność (484)
  
• 25.3. Praca z innymi klasami obsługującymi ciągi znaków (487)
  
• 25.4. Inicjalizacja łączenia (488)
  
• 25.5. Patologiczne nawiasowanie (489)
  
• 25.6. Standaryzacja (490)

Rozdział 26. Jaki jest Twój adres? (491)


• 26.1. Nie można pobrać rzeczywistego adresu (491)
  
• 26.2. Co dzieje się w czasie konwersji? (494)
  
• 26.3. Co zwracać? (496)
  
• 26.4. Jaki jest Twój adres - podsumowanie (498)

Rozdział 27. Operatory indeksowania (501)


• 27.1. Przekształcanie wskaźników i operatory indeksowania (501)
  
• 27.2. Obsługa błędów (504)
  
• 27.3. Zwracana wartość (506)

Rozdział 28. Operatory inkrementacji (509)


• 28.1. Brakujące operatory przyrostkowe (510)
  
• 28.2. Wydajność (511)

Rozdział 29. Typy arytmetyczne (515)


• 29.1. Definicja klasy (515)
  
• 29.2. Konstruktor domyślny (516)
  
• 29.3. Inicjalizacja (nadawanie wartości) (517)
  
• 29.4. Konstruktor kopiujący (519)
  
• 29.5. Przypisanie (519)
  
• 29.6. Operatory arytmetyczne (520)
  
• 29.7. Operatory porównania (520)
  
• 29.8. Dostęp do wartości (521)
  
• 29.9. Klasa SInteger64 (521)
  
• 29.10. Obcinanie, promocja do większego typu i testowanie warunków (522)
  
• 29.11. Typy arytmetyczne - podsumowanie (525)

Rozdział 30. Skrócona ewaluacja (527)


Część VI Rozszerzanie możliwości języka C++ (529)


Rozdział 31. Czas życia wartości zwracanej (531)


• 31.1. Klasyfikacja problemów związanych z czasem życia wartości zwracanej (532)
  
• 31.2. Do czego służy zwracanie przez referencję? (533)
  
• 31.3. Rozwiązanie pierwsze - szablon integer_to_string<> (533)
  
• 31.4. Rozwiązanie drugie - mechanizm TSS (536)
  
• 31.5. Rozwiązanie trzecie - rozszerzanie RVL (541)
  
• 31.6. Rozwiązanie czwarte - statyczne określanie rozmiaru tablicy (543)
  
• 31.7. Rozwiązanie piąte - podkładki konwertujące (545)
  
• 31.8. Wydajność (547)
  
• 31.9. RVL - wielkie zwycięstwo automatycznego przywracania pamięci (548)
  
• 31.10. Potencjalne zastosowania (549)
  
• 31.11. RVL - podsumowanie (549)

Rozdział 32. Pamięć (551)


• 32.1. Rodzaje pamięci (551)
  
• 32.2. Najlepsze w obu rodzajach (553)
  
• 32.3. Alokatory (565)
  
• 32.4. Pamięć - podsumowanie (569)

Rozdział 33. Tablice wielowymiarowe (571)


• 33.1. Udostępnianie składni indeksowania (572)
  
• 33.2. Określanie rozmiaru w czasie wykonywania programu (573)
  
• 33.3. Określanie rozmiaru na etapie kompilacji (579)
  
• 33.4. Dostęp blokowy (582)
  
• 33.5. Wydajność (586)
  
• 33.6. Tablice wielowymiarowe - podsumowanie (589)

Rozdział 34. Funktory i zakresy (591)


• 34.1. Bałagan składniowy (591)
  
• 34.2. Funkcja for_all() (592)
  
• 34.3. Funktory lokalne (595)
  
• 34.4. Zakresy (604)
  
• 34.5. Funktory i zakresy - podsumowanie (612)

Rozdział 35. Właściwości (613)


• 35.1. Rozszerzenia kompilatora (615)
  
• 35.2. Sposoby implementacji (616)
  
• 35.3. Właściwości pola (617)
  
• 35.4. Właściwości metody (624)
  
• 35.5. Właściwości statyczne (638)
  
• 35.6. Właściwości wirtualne (642)
  
• 35.7. Zastosowania właściwości (642)
  
• 35.8. Właściwości - podsumowanie (645)

Dodatki (647)


Dodatek A Kompilatory i biblioteki (649)


• A.1. Kompilatory (649)
  
• A.2. Biblioteki (651)
  
• A.3. Inne źródła (653)

Dodatek B Pycha w końcu Cię zgubi! (655)


• B.1. Przeciążanie operatora (656)
  
• B.2. Jak zawiodło DRY (657)
  
• B.3. Programowanie paranoiczne (657)
  
• B.4. Do szaleństwa i jeszcze dalej (658)

Dodatek C Arturius (661)


Dodatek D Płyta CD (663)


Epilog (665)


Bibliografia (667)


Skorowidz (675)

pokaż cały spis treści

ukryj recenzje