C++. Szablony. Vademecum profesjonalisty

Spis treści 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)

pokaż cały spis treści

ukryj recenzje