C_Szablony_Vademecum_profesjonalisty_cpszav.pdf

(212 KB) Pobierz
IDZ DO
PRZYK£ADOWY ROZDZIA£
SPIS TRE CI
KATALOG KSI¥¯EK
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
C++. Szablony.
Vademecum
profesjonalisty
Autorzy: David Vandevoorde, Nicolai M. Josuttis
T³umaczenie: Przemys³aw Szeremiota
ISBN: 83-7361-175-4
Tytu³ orygina³u:
C++ Templates The Complete Guide
Format: B5, stron: 474
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.
TWÓJ KOSZYK
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWO CIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
5RKU VTG EK
2T\GFOQYC
Rozdział 1.
1 MUKæ EG
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
%\ú è +
Rozdział 2.
2QFUVCY[
5\CDNQP[ HWPMELK
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.
5\CDNQP[ MNCU
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.
2Q\CV[RQYG RCTCOGVT[ U\CDNQPÎY
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.
-KNMC U\VWE\GM
5.1. Słowo kluczowe typename ................................................................................... 53
5.2. Zastosowanie odwołania this–> ............................................................................. 55
5.3. Szablony składowych ........................................................................................... 55
6
C++. Szablony. Vademecum profesjonalisty
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.
2TCMV[E\PG \CUVQUQYCPKG U\CDNQPÎY
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.
2QFUVCYQYG RQLúEKC \YKæ\CPG \ U\CDNQPCOK
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
%\ú è ++
Rozdział 8.
5\CDNQP[ \ DNKUMC
2QFUVCY[
FTWIKG RT\[DNK GPKG
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
Spis treści
7
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.
0C\Y[ Y U\CDNQPCEJ
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.
-QPMTGV[\CELC
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.
&GFWMELC CTIWOGPVÎY U\CDNQPW
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.
5RGELCNK\CELG K RT\GEKæ CPKG
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
8
C++. Szablony. Vademecum profesjonalisty
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.
-KGTWPMK TQ\YQLW
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
%\ú è +++
Rozdział 14.
5\CDNQP[ Y RTQLGMVQYCPKW
5K C RQNKOQTHK\OW U\CDNQPÎY
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.
-NCU[ EGEJ K Y[V[E\P[EJ
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

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin