C++. Szabloby. Vademecum profesjonalisty.pdf

(224 KB) Pobierz
C:\Andrzej\PDF\ABC nagrywania p³yt CD\1 strona.cdr
IDZ DO
PRZYK£ADOW Y ROZDZIA£
C++. Szablony.
SPIS TRECI
Vademecum
KATALOG KSI¥¯EK
profesjonalisty
Autorzy: David Vandevoorde, Nicolai M. Josuttis
T³umaczenie: Przemys³aw Szeremiota
ISBN: 83-7361-175-4
Format: B5, stron: 474
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
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 ronie. 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¿liwoci, jak równie¿ wiedzy pomagaj¹cej dowiadczonym 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 wydajnoci i bezpieczeñstwa,
• sposoby zwiêkszania efektywnoci 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. Jeli w programowaniu
w C++ chcesz osi¹gn¹æ najwy¿szy poziom, nie obêdziesz siê bez tej ksi¹¿ki.
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWOCIACH
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
329225144.003.png 329225144.004.png 329225144.005.png 329225144.006.png 329225144.001.png 329225144.002.png
Rozdział 1.
1.1. Co naley wiedzie przed przystpieniem do lektury? ............................................. 16
1.2. Struktura ogólna ksiki ....................................................................................... 16
1.3. Jak czyta t" ksik"?........................................................................................... 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.
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. Przecianie szablonów funkcji............................................................................. 29
2.5. Podsumowanie .................................................................................................... 33
Rozdział 3.
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.
! "#
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.
$
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 ła9cuchowe jako argumenty szablonów funkcji .......................................... 64
5.7. Podsumowanie .................................................................................................... 67
Rozdział 6.
!%&
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 ko9cowe................................................................................................... 91
6.8. Podsumowanie .................................................................................................... 92
Rozdział 7.
' &
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.
() *
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ównowano& argumentów ...................................................................... 117
Spis treci
7
8.4. Deklaracje zaprzyjaCnione .................................................................................. 117
8.4.1. Funkcje zaprzyjaCnione.............................................................................. 118
8.4.2. Szablony jednostek zaprzyjaCnionych.......................................................... 120
8.5. Uwagi ko9cowe................................................................................................. 121
Rozdział 9.
+,
9.1. Taksonomia nazw.............................................................................................. 123
9.2. Wyszukiwanie nazw........................................................................................... 125
9.2.1. Wyszukiwanie według argumentów ............................................................ 126
9.2.2. Wtrcanie nazw zaprzyjaCnionych .............................................................. 128
9.2.3. Wtrcane nazwy klas ................................................................................. 129
9.3. Analiza składniowa szablonów............................................................................ 130
9.3.1. Wraliwo& kontekstowa poza szablonami................................................... 130
9.3.2. Zalene nazwy typów ................................................................................ 133
9.3.3. Zalene nazwy szablonów.......................................................................... 134
9.3.4. Nazwy zalene w deklaracjach uywanych 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 niezalene............................................................................ 138
9.4.2. Klasy bazowe zalene................................................................................ 138
9.5. Uwagi ko9cowe................................................................................................. 141
Rozdział 10. $ "
10.1. Konkretyzacja na danie ................................................................................. 143
10.2. Konkretyzacja opóCniona.................................................................................. 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 ko9cowe ............................................................................................... 165
Rozdział 11. -)! %#
11.1. Proces dedukcji................................................................................................ 167
11.2. Konteksty dedukowane .................................................................................... 169
11.3. Sytuacje wyjtkowe 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 ko9cowe ............................................................................................... 176
Rozdział 12. ##
12.1. Kiedy kod uogólniony nie jest odpowiedni?........................................................ 177
12.1.1. Przezroczysto& dopasowania ................................................................... 178
12.1.2. Przezroczysto& semantyczna ................................................................... 179
12.2. Przecianie szablonów funkcji ......................................................................... 180
12.2.1. Sygnatury ............................................................................................... 181
12.2.2. Porzdkowanie cz"&ciowe przecionych szablonów funkcji ....................... 183
8
C++. Szablony. Vademecum profesjonalisty
12.2.3. Formalne reguły porzdkowania................................................................ 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 ko9cowe ............................................................................................... 198
Rozdział 13. $ *
13.1. Problem nawiasów ostrych ............................................................................... 201
13.2. LuCne reguły deklaracji typename...................................................................... 202
13.3. Domy&lne argumenty szablonów funkcji ............................................................ 203
13.4. Literały ła9cuchowe i zmiennoprzecinkowe jako argumenty szablonów................ 204
13.5. LuCne 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. Przecione 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. Wyraenia funkcyjne...................................................................................... 220
13.17. Uwagi ko9cowe ............................................................................................. 222
Rozdział 14. . !
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 ko9cowe ............................................................................................... 235
Rozdział 15. $,, #
15.1. Przykład — kumulowanie cigu 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 uytkownika..................................... 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