Katalog książek

Wydawnictwo Helion

Helion SA
ul. Kościuszki 1c
44-100 Gliwice
tel. (32) 230-98-63




© Helion 1991-2016

Lauret zaufanych opinii
C++. Szablony. Vademecum profesj...

C++. Szablony. Vademecum profesjonalisty

Autorzy: ,

C++. Szablony. Vademecum profesjonalisty
Ocena:
   6/6  Opinie  (2)
Stron: 480
Ksiazka drukowana Druk (oprawa: twarda)
Wydawca: Helion

Choć szablony są częścią definicji języka C++ od ponad dziesięciu lat, wciąż są źródłem nieporozumień, omyłek i kontrowersji. Z drugiej strony, ich popularność jako efektywnych instrumentów tworzenia bardziej eleganckiego, szybszego i "inteligentniejszego" oprogramowania stale rośnie. W rzeczy samej, szablony osiągnęły rangę kamieni węgielnych dla kilku nowych modeli programowania w języku C++.

Książka "C++. Szablony. Vademecum profesjonalisty." zawiera komplet informacji niezbędnych do rozpoczęcia korzystania z szablonów i pełnego wykorzystania ich możliwości, jak również wiedzy pomagającej doświadczonym programistom przekroczyć granicę, za którą programowanie z rzemiosła staje się sztuką. Autorzy założyli, że znasz język C++ i potrafisz programować z wykorzystaniem komponentów biblioteki standardowej. Prezentowane w książce przykłady znakomicie ilustrują abstrakcyjne pojęcia i demonstrują najlepsze praktyki programistyczne.

Poznasz:

  • sposoby unikania pułapek towarzyszących stosowaniu szablonów,
  • idiomy i techniki związane z szablonami -- od technik najprostszych do takich, które poza tą książką nie zostały jeszcze nigdzie dokumentowane,
  • sposoby wielokrotnego wykorzystywania tego samego kodu źródłowego bez zmniejszania jego wydajności i bezpieczeństwa,
  • sposoby zwiększania efektywności programów w języku C++,
  • sposoby tworzenia oprogramowania bardziej elastycznego i łatwiejszego w utrzymaniu.
Niektóre z technik przestawionych w "C++. Szablony. Vademecum profesjonalisty" nie doczekały się jeszcze opracowania w innych publikacjach. Jeśli w programowaniu w C++ chcesz osiągnąć najwyższy poziom, nie obędziesz się bez tej książki.
Przedmowa (13)
Rozdział 1. O książce (15)
  • 1.1. Co należy wiedzieć przed przystąpieniem do lektury? (16)
  • 1.2. Struktura ogólna książki (16)
  • 1.3. Jak czytać tę książkę? (17)
  • 1.4. Uwagi do stosowanego w tekście stylu programowania (17)
  • 1.5. Standard a rzeczywistość (19)
  • 1.6. Pliki przykładów i dodatkowe informacje (20)
Część I Podstawy (21)
Rozdział 2. Szablony funkcji (23)
  • 2.1. Szablony funkcji - wstęp (23)
    • 2.1.1. Definiowanie szablonu (23)
    • 2.1.2. Korzystanie z szablonu (24)
  • 2.2. Dedukcja typu argumentów (26)
  • 2.3. Parametry szablonu (27)
  • 2.4. Przeciążanie szablonów funkcji (29)
  • 2.5. Podsumowanie (33)
Rozdział 3. Szablony klas (35)
  • 3.1. Implementacja szablonu klasy Stack (35)
    • 3.1.1. Deklarowanie szablonów klas (36)
    • 3.1.2. Implementacja metod klasy (37)
  • 3.2. Korzystanie z szablonu klasy Stack (38)
  • 3.3. Specjalizacje szablonów klas (40)
  • 3.4. Specjalizacja częściowa (42)
  • 3.5. Domyślne argumenty szablonu (43)
  • 3.6. Podsumowanie (45)
Rozdział 4. Pozatypowe parametry szablonów (47)
  • 4.1. Pozatypowe parametry szablonów klas (47)
  • 4.2. Pozatypowe parametry szablonów funkcji (50)
  • 4.3. Ograniczenia dla pozatypowych parametrów szablonów (51)
  • 4.4. Podsumowanie (52)
Rozdział 5. Kilka sztuczek (53)
  • 5.1. Słowo kluczowe typename (53)
  • 5.2. Zastosowanie odwołania this-( (55)
  • 5.3. Szablony składowych (55)
  • 5.4. Szablony parametrów szablonów (59)
  • 5.5. Inicjalizacja zerowa (63)
  • 5.6. Literały łańcuchowe jako argumenty szablonów funkcji (64)
  • 5.7. Podsumowanie (67)
Rozdział 6. Praktyczne zastosowanie szablonów (69)
  • 6.1. Model włączania (69)
    • 6.1.1. Komunikaty o błędach konsolidacji (69)
    • 6.1.2. Szablony w plikach nagłówkowych (71)
  • 6.2. Konkretyzacja jawna (72)
    • 6.2.1. Przykład konkretyzacji jawnej (73)
    • 6.2.2. Połączenie modelu włączania i konkretyzacji jawnej (74)
  • 6.3. Model separacji (75)
    • 6.3.1. Słowo kluczowe export (75)
    • 6.3.2. Ograniczenia modelu separacji (77)
    • 6.3.3. Przygotowanie do wykorzystania modelu separacji (78)
  • 6.4. Szablony a słowo kluczowe inline (79)
  • 6.5. Wstępna kompilacja plików nagłówkowych (79)
  • 6.6. Diagnostyka szablonów (82)
    • 6.6.1. Dekodowanie elaboratu o błędzie (82)
    • 6.6.2. Konkretyzacja płytka (84)
    • 6.6.3. Zbyt długie symbole (86)
    • 6.6.4. Tropiciele (86)
    • 6.6.5. Wyrocznie (90)
    • 6.6.6. Archetypy (91)
  • 6.7. Uwagi końcowe (91)
  • 6.8. Podsumowanie (92)
Rozdział 7. Podstawowe pojęcia związane z szablonami (93)
  • 7.1. "Szablon klasy" czy "klasa szablonowa"? (93)
  • 7.2. Konkretyzacja i specjalizacja (94)
  • 7.3. Deklaracje i definicje (94)
  • 7.4. Reguła pojedynczej definicji (95)
  • 7.5. Parametry czy argumenty szablonów? (96)
Część II Szablony z bliska (99)
Rozdział 8. Podstawy - drugie przybliżenie (101)
  • 8.1. Deklaracje sparametryzowane (101)
    • 8.1.1. Wirtualne funkcje składowe (104)
    • 8.1.2. Łączenie szablonów (104)
    • 8.1.3. Szablony podstawowe (105)
  • 8.2. Parametry szablonów (105)
    • 8.2.1. Parametry typów (106)
    • 8.2.2. Parametry pozatypowe (106)
    • 8.2.3. Szablony parametrów szablonów (107)
    • 8.2.4. Domyślne argumenty szablonów (108)
  • 8.3. Argumenty szablonu (109)
    • 8.3.1. Argumenty szablonów funkcji (110)
    • 8.3.2. Argumenty typów (112)
    • 8.3.3. Argumenty pozatypowe (113)
    • 8.3.4. Argumenty szablonów parametrów szablonów (115)
    • 8.3.5. Równoważność argumentów (117)
  • 8.4. Deklaracje zaprzyjaźnione (117)
    • 8.4.1. Funkcje zaprzyjaźnione (118)
    • 8.4.2. Szablony jednostek zaprzyjaźnionych (120)
  • 8.5. Uwagi końcowe (121)
Rozdział 9. Nazwy w szablonach (123)
  • 9.1. Taksonomia nazw (123)
  • 9.2. Wyszukiwanie nazw (125)
    • 9.2.1. Wyszukiwanie według argumentów (126)
    • 9.2.2. Wtrącanie nazw zaprzyjaźnionych (128)
    • 9.2.3. Wtrącane nazwy klas (129)
  • 9.3. Analiza składniowa szablonów (130)
    • 9.3.1. Wrażliwość kontekstowa poza szablonami (130)
    • 9.3.2. Zależne nazwy typów (133)
    • 9.3.3. Zależne nazwy szablonów (134)
    • 9.3.4. Nazwy zależne w deklaracjach używanych przestrzeni nazw i klas (136)
    • 9.3.5. ADL a jawne argumenty szablonu (137)
  • 9.4. Szablony klas wyprowadzonych (137)
    • 9.4.1. Klasy bazowe niezależne (138)
    • 9.4.2. Klasy bazowe zależne (138)
  • 9.5. Uwagi końcowe (141)
Rozdział 10. Konkretyzacja (143)
  • 10.1. Konkretyzacja na żądanie (143)
  • 10.2. Konkretyzacja opóźniona (145)
  • 10.3. Model konkretyzacji z języku C++ (147)
    • 10.3.1. Wyszukiwanie dwufazowe (148)
    • 10.3.2. Punkty konkretyzacji (148)
    • 10.3.3. Modele włączania i separacji (151)
    • 10.3.4. Wyszukiwanie pomiędzy jednostkami translacji (152)
    • 10.3.5. Przykłady (153)
  • 10.4. Schematy implementacji (154)
    • 10.4.1. Konkretyzacja zachłanna (156)
    • 10.4.2. Konkretyzacja z bazą danych (157)
    • 10.4.3. Konkretyzacja iterowana (159)
  • 10.5. Konkretyzacja jawna (161)
  • 10.6. Uwagi końcowe (165)
Rozdział 11. Dedukcja argumentów szablonu (167)
  • 11.1. Proces dedukcji (167)
  • 11.2. Konteksty dedukowane (169)
  • 11.3. Sytuacje wyjątkowe procesu dedukcji (171)
  • 11.4. Dopuszczalne konwersje argumentów (172)
  • 11.5. Parametry szablonów klas (173)
  • 11.6. Domyślne argumenty wywołania (173)
  • 11.7. Technika Bartona-Nackmana (174)
  • 11.8. Uwagi końcowe (176)
Rozdział 12. Specjalizacje i przeciążanie (177)
  • 12.1. Kiedy kod uogólniony nie jest odpowiedni? (177)
    • 12.1.1. Przezroczystość dopasowania (178)
    • 12.1.2. Przezroczystość semantyczna (179)
  • 12.2. Przeciążanie szablonów funkcji (180)
    • 12.2.1. Sygnatury (181)
    • 12.2.2. Porządkowanie częściowe przeciążonych szablonów funkcji (183)
    • 12.2.3. Formalne reguły porządkowania (184)
    • 12.2.4. Szablony funkcji a funkcje zwykłe (186)
  • 12.3. Specjalizacja jawna (187)
    • 12.3.1. Pełna specjalizacja szablonu klasy (187)
    • 12.3.2. Pełna specjalizacja szablonu funkcji (191)
    • 12.3.3. Pełna specjalizacja składowej (193)
  • 12.4. Częściowa specjalizacja szablonu klasy (195)
  • 12.5. Uwagi końcowe (198)
Rozdział 13. Kierunki rozwoju (201)
  • 13.1. Problem nawiasów ostrych (201)
  • 13.2. Luźne reguły deklaracji typename (202)
  • 13.3. Domyślne argumenty szablonów funkcji (203)
  • 13.4. Literały łańcuchowe i zmiennoprzecinkowe jako argumenty szablonów (204)
  • 13.5. Luźne dopasowanie szablonów parametrów szablonów (206)
  • 13.6. Szablony definicji typu (207)
  • 13.7. Specjalizacja częściowa szablonów funkcji (209)
  • 13.8. Operator typeof (210)
  • 13.9. Nazwane argumenty szablonu (212)
  • 13.10. Właściwości statyczne typów (213)
  • 13.11. Własna diagnostyka konkretyzacji (213)
  • 13.12. Przeciążone szablony klas (216)
  • 13.13. Parametry wielokrotne (216)
  • 13.14. Kontrola rozmieszczenia w pamięci (218)
  • 13.15. Dedukcja typu na podstawie inicjalizatora (219)
  • 13.16. Wyrażenia funkcyjne (220)
  • 13.17. Uwagi końcowe (222)
Część III Szablony w projektowaniu (223)
Rozdział 14. Siła polimorfizmu szablonów (225)
  • 14.1. Polimorfizm dynamiczny (225)
  • 14.2. Polimorfizm statyczny (228)
  • 14.3. Polimorfizm statyczny kontra dynamiczny (230)
  • 14.4. Nowe formy wzorców projektowych (232)
  • 14.5. Programowanie ogólne (233)
  • 14.6. Uwagi końcowe (235)
Rozdział 15. Klasy cech i wytycznych (237)
  • 15.1. Przykład - kumulowanie ciągu elementów (237)
    • 15.1.1. Cechy ustalone (238)
    • 15.1.2. Cechy wartości (241)
    • 15.1.3. Parametryzacja cech (244)
    • 15.1.4. Wytyczne i klasy wytycznych (246)
    • 15.1.5. Czym różnią się cechy i wytyczne? (248)
    • 15.1.6. Szablony składowe a szablony parametrów szablonów (249)
    • 15.1.7. Łączenie wielu cech i wytycznych (251)
    • 15.1.8. Kumulowanie za pomocą iteratorów ogólnych (251)
  • 15.2. Funkcje typów (252)
    • 15.2.1. Określanie typu elementu (253)
    • 15.2.2. Określanie typu definiowanego przez użytkownika (255)
    • 15.2.3. Referencje i kwalifikatory (257)
    • 15.2.4. Cechy promocji (259)
  • 15.3. Cechy wytycznych (262)
    • 15.3.1. Parametry typów tylko do odczytu (263)
    • 15.3.2. Kopiowanie, wymiana i przenoszenie (266)
  • 15.4. Uwagi końcowe (270)
Rozdział 16. Szablony i dziedziczenie (271)
  • 16.1. Nazwane argumenty szablonów (271)
  • 16.2. Optymalizacja pustej klasy bazowej (274)
    • 16.2.1. Zasady rozmieszczania klas w pamięci (275)
    • 16.2.2. Klasy bazowe w postaci składowych (277)
  • 16.3. Wzorzec CRTP (279)
  • 16.4. Parametryzacja wirtualności metod (281)
  • 16.5. Uwagi końcowe (282)
Rozdział 17. Metaprogramy (285)
  • 17.1. Metaprogram - pierwsza odsłona (285)
  • 17.2. Wartości wyliczeniowe a stałe statyczne (287)
  • 17.3. Przykład drugi - obliczanie pierwiastka kwadratowego (288)
  • 17.4. Zmienne indukowane (292)
  • 17.5. Zupełność obliczeniowa (295)
  • 17.6. Konkretyzacja rekurencyjna a rekurencyjne argumenty szablonów (296)
  • 17.7. Metaprogramowanie w rozwijaniu pętli (297)
  • 17.8. Uwagi końcowe (300)
Rozdział 18. Szablony wyrażeń (303)
  • 18.1. Obiekty tymczasowe i rozdzielanie pętli (304)
  • 18.2. Kodowanie wyrażeń obliczeniowych za pomocą argumentów szablonów (308)
    • 18.2.1. Operandy szablonów wyrażeń (309)
    • 18.2.2. Typ Array (312)
    • 18.2.3. Operatory (314)
    • 18.2.4. Podsumowanie (315)
    • 18.2.5. Przypisania szablonów wyrażeń (317)
  • 18.3. Wydajność szablonów wyrażeń i ich ograniczenia (318)
  • 18.4. Uwagi końcowe (319)
Część IV Zaawansowane zastosowania szablonów (323)
Rozdział 19. Klasyfikacja typów (325)
  • 19.1. Identyfikowanie typów podstawowych (325)
  • 19.2. Identyfikowanie typów złożonych (327)
  • 19.3. Identyfikowanie typów funkcyjnych (329)
  • 19.4. Klasyfikacja typów wyliczeniowych przez rozstrzyganie przeciążenia (333)
  • 19.5. Identyfikowanie typów definiowanych przez użytkownika (335)
  • 19.6. Jak to wszystko połączyć? (336)
  • 19.7. Uwagi końcowe (338)
Rozdział 20. Inteligentne wskaźniki (341)
  • 20.1. Posiadacze i kuriery (341)
    • 20.1.1. Ochrona przed wyjątkami (342)
    • 20.1.2. Klasa posiadacza (343)
    • 20.1.3. Posiadacze jako składowe (346)
    • 20.1.4. Pozyskiwanie zasobów w inicjalizacji (347)
    • 20.1.5. Ograniczenia klasy posiadacza (348)
    • 20.1.6. Kopiowanie posiadaczy (349)
    • 20.1.7. Kopiowanie obiektów posiadaczy pomiędzy wywołaniami funkcji (350)
    • 20.1.8. Obiekty kurierów (351)
  • 20.2. Zliczanie liczby odwołań (353)
    • 20.2.1. Gdzie umieścić licznik? (354)
    • 20.2.2. Współbieżny dostęp do licznika (355)
    • 20.2.3. Niszczenie a zwalnianie (356)
    • 20.2.4. Szablon CountingPtr (357)
    • 20.2.5. Prosty licznik nieinwazyjny (360)
    • 20.2.6. Szablon prostego licznika inwazyjnego (361)
    • 20.2.7. Stałość (362)
    • 20.2.8. Konwersje niejawne (363)
    • 20.2.9. Porównania (366)
  • 20.3. Uwagi końcowe (367)
Rozdział 21. Krotki (369)
  • 21.1. Duety (369)
  • 21.2. Duety rekurencyjne (374)
    • 21.2.1. Liczba pól duetów rekurencyjnych (374)
    • 21.2.2. Typy pól duetów rekurencyjnych (375)
    • 21.2.3. Wartości pól duetów rekurencyjnych (376)
  • 21.3. Konstruowanie krotek (380)
  • 21.4. Uwagi końcowe (384)
Rozdział 22. Obiekty funkcyjne i funkcje zwrotne (385)
  • 22.1. Wywołania bezpośrednie, pośrednie i rozwijane w miejscu wywołania (386)
  • 22.2. Wskaźniki i referencje do funkcji (389)
  • 22.3. Wskaźniki do metod (391)
  • 22.4. Funktory typów definiowanych przez użytkownika (394)
    • 22.4.1. Pierwszy przykład funktora typu definiowanego przez użytkownika (394)
    • 22.4.2. Typy funktorów typów definiowanych przez użytkownika (395)
  • 22.5. Przekazywanie funktorów (397)
    • 22.5.1. Funktory jako argumenty typu szablonów (397)
    • 22.5.2. Funktory jako argumenty wywołania funkcji (398)
    • 22.5.3. Połączenie parametrów wywołania funkcji z parametrami typu szablonu (399)
    • 22.5.4. Funktory jako pozatypowe argumenty szablonów (399)
    • 22.5.5. Kapsułkowanie wskaźnika do funkcji (400)
  • 22.6. Introspekcja (403)
    • 22.6.1. Analiza typu funktora (403)
    • 22.6.2. Dostęp do parametrów typów (404)
    • 22.6.3. Kapsułkowanie wskaźników do funkcji (406)
  • 22.7. Składanie obiektu funkcyjnego (410)
    • 22.7.1. Złożenie proste (411)
    • 22.7.2. Składanie funktorów mieszanych typów (414)
    • 22.7.3. Zmniejszanie liczby parametrów (417)
  • 22.8. Wiązania wartości (420)
    • 22.8.1. Wybór wiązania (420)
    • 22.8.2. Sygnatura wiązania (422)
    • 22.8.3. Wybór argumentów (423)
    • 22.8.4. Funkcje pomocnicze (428)
  • 22.9. Operacje na funktorach - pełna implementacja (430)
  • 22.10. Uwagi końcowe (433)
Dodatki (435)
Dodatek A Reguła pojedynczej definicji (437)
  • A.1. Jednostki translacji (437)
  • A.2. Deklaracje i definicje (438)
  • A.3. Reguła pojedynczej definicji z bliska (439)
    • A.3.1. Jedna definicja w programie (439)
    • A.3.2. Jedna definicja w jednostce translacji (441)
    • A.3.3. Równoważność definicji pomiędzy jednostkami translacji (443)
Dodatek B Rozstrzyganie przeciążenia (449)
  • B.1. Kiedy potrzebne jest rozstrzyganie przeciążenia? (450)
  • B.2. Uproszczone rozstrzyganie przeciążenia (450)
    • B.2.1. Niejawny argument metod (452)
    • B.2.2. Doskonalenie idealnego dopasowania (454)
  • B.3. Przeciążanie z bliska (455)
    • B.3.1. Dyskryminacja szablonów (455)
    • B.3.2. Sekwencje konwersji (456)
    • B.3.3. Konwersje wskaźników (456)
    • B.3.4. Funktory i funkcje zastępcze (458)
    • B.3.5. Inne konteksty przeciążania (459)
Dodatek C Bibliografia (461)
  • Grupy dyskusyjne (461)
  • Książki i witryny WWW (462)
Skorowidz (465)
6
(2)
5
(0)
4
(0)
3
(0)
2
(0)
1
(0)

Liczba ocen: 2

Średnia ocena
czytelników

  


okladka
  Ocena : 6 

Znajomość nauki zaawansowanego programowania powinna zacząć się od tej książki. Poznanie najnowszego standardu C++ sprawia, że milsza jest praca z obiektami. Super książka.
  Ocena : 6 

Jest to wszystko i o wiele więcej niż może sobie wymarzyć programista, który chce sprawnie posługiwać się szablonami. Przede wszystkim warto docenić to, że opisuje ona zagadnienia nie poruszane w żadnej innej książce o C++, zatem może służyć w przypadku wątpliwości w zaawansowanym stosowaniu szablonów. Część przykładów jest wprawdzie bardziej teoretyczna niż praktyczna, jednak doskonale pokazują one potęgę szablonów C++. Pozycja obowiązkowa w biblioteczce każdego zaawansowanego programisty.