Katalog książek

Bony podarunkowe

Autorzy Nowości eBooki Bestsellery Zapowiedzi Przedsprzedaż Najlepiej oceniane Druk na żądanie

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

© Helion 1991-2013

Strona główna »

C++. Szablony. Vademecum profesj...

C++. Szablony. Vademecum profesjonalisty

Autorzy: David Vandevoorde, Nicolai M. Josuttis

Ocena:

6/6 Opinie (2)

Stron: 480

Druk (oprawa: twarda)

Powiadom mnie, gdy książka będzie dostępna w druku na żądanie

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.

Tytuł oryginału: C++ Templates The Complete Guide
Tłumaczenie: Przemysław Szeremiota
ISBN Książki drukowanej: 83-7361-175-4, 8373611754
Data wydania książki drukowanej: 2003-07-23
Format: B5
Numer z katalogu: 2216
Pobierz przykładowy rozdział PDF
Przykłady na ftp
Erraty / Zgłoś erratę
Poinformuj znajomego o książce
Czytaj: opis, spis treści
Kategorie:
Programowanie » C++ - Programowanie
Serie wydawnicze:
Vademecum profesjonalisty

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)

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.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

Oceń książkę

Ocena : 6

2004-08-25

Zapadka Robert

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

2005-02-09

Karol Kuczmarski

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.