C++. Szablony. Vademecum profesjonalisty

IDZ DO
PRZYK£ADOWY ROZDZIA£

SPIS TRE CI C++. Szablony.
Vademecum
KATALOG KSI¥¯EK
KATALOG ONLINE
profesjonalisty
Autorzy: David Vandevoorde, Nicolai M. Josuttis
T³umaczenie: Przemys³aw Szeremiota
ZAMÓW DRUKOWANY KATALOG ISBN: 83-7361-175-4
Tytu³ orygina³u: C++ Templates The Complete Guide
TWÓJ KOSZYK
Format: B5, stron: 474

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
CENNIK I INFORMACJE i „inteligentniejszego” oprogramowania stale ro nie. W rzeczy samej, szablony
osi¹gnê³y rangê kamieni wêgielnych dla kilku nowych modeli programowania
ZAMÓW INFORMACJE w jêzyku C++.
O NOWO CIACH Ksi¹¿ka "C++. Szablony. Vademecum profesjonalisty." zawiera komplet informacji
niezbêdnych do rozpoczêcia korzystania z szablonów i pe³nego wykorzystania ich
ZAMÓW CENNIK 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
CZYTELNIA biblioteki standardowej. Prezentowane w ksi¹¿ce przyk³ady znakomicie ilustruj¹
abstrakcyjne pojêcia i demonstruj¹ najlepsze praktyki programistyczne.
FRAGMENTY KSI¥¯EK ONLINE 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
Wydawnictwo Helion w C++ chcesz osi¹gn¹æ najwy¿szy poziom, nie obêdziesz siê bez tej ksi¹¿ki.
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl

5RKU VTG EK
2TGFOQYC
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

%ú è + 2QFUVCY[
Rozdział 2. 5CDNQP[ 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. 5CDNQP[ 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. 2QCV[RQYG RCTCOGVT[ UCDNQPÎ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 UVWEGM
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[EPG CUVQUQYCPKG UCDNQPÎ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 UCDNQPCOK
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

%ú è ++ 5CDNQP[ DNKUMC
Rozdział 8. 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. 0CY[ Y UCDNQPCEJ
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 UCDNQPW
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. 5RGELCNKCELG K RTGEKæ 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


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

%ú è +++ 5CDNQP[ Y RTQLGMVQYCPKW
Rozdział 14. 5K C RQNKOQTHKOW UCDNQPÎ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[EP[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

Spis treści 9

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. 5CDNQP[ K FKGFKEGPKG
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. /GVCRTQITCO[
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. 5CDNQP[ Y[TC G
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

%ú è +8 CCYCPUQYCPG CUVQUQYCPKC UCDNQPÎY
Rozdział 19. -NCU[HKMCELC V[RÎY
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. +PVGNKIGPVPG YUMC PKMK
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. -TQVMK
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. 1DKGMV[ HWPME[LPG K HWPMELG YTQVPG
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

Spis treści 11

QFCVMK
Dodatek A 4GIW C RQLGF[PEGL FGHKPKELK
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 4QUVT[ICPKG RTGEKæ GPKC
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 $KDNKQITCHKC
Grupy dyskusyjne .................................................................................................... 461
Ksią ki i witryny WWW........................................................................................... 462

5MQTQYKF

Rozdział 2.
5CDNQP[ HWPMELK
W rozdziale tym wprowadzimy pojęcie szablonu funkcji. Szablony funkcji to funkcje
sparametryzowane tak, aby mogły reprezentować całe rodziny funkcji.

5CDNQP[ HWPMELK YUVúR
Szablony funkcji definiują kod, który mo e być realizowany dla ró nych typów danych.
Innymi słowy, szablon funkcji reprezentuje rodzinę funkcji. Reprezentacja ta przypomi-
na zwykłą funkcję języka C++, pozbawioną tylko ścisłego określenia niektórych ele-
mentów. Elementy te są więc sparametryzowane. Najlepiej wytłumaczymy to na prostym
przykładzie.

GHKPKQYCPKG UCDNQPW

Poni szy kod stanowi deklarację szablonu funkcji zwracającej większą z dwu przekaza-
nych do niej wartości:
RQFUVCY[OCZJRR

VGORNCVG V[RGPCOG 6
KPNKPG 6 EQPUV OCZ
6 EQPUV C 6 EQPUV D
]
LG GNK C D YTÎè D Y RTGEKYP[O RT[RCFMW YTÎè C
TGVWTP C D ! D C
_

Szablon ten definiuje rodzinę funkcji, które zwracają większą z dwu przekazanych do
nich wartości (przekazanie odbywa się za pośrednictwem parametrów wywołania funk-
cji: C i D). Typ parametrów funkcji nie został jawnie określony i występuje w szablonie
jako parametr szablonu 6. Przykład pokazuje, e parametry szablonów muszą zostać
podane w ramach następującej konstrukcji składniowej:
VGORNCVG NKUVCRCTCOGVTÎYQFFKGNCP[EJRTGEKPMCOK

W prezentowanym przykładzie lista parametrów zawiera wyra enie V[RGPCOG 6. Cha-
rakterystyczne jest umieszczenie listy parametrów szablonu pomiędzy znakami mniej-
szości () i większości () — utworzone tak nawiasy nazywamy nawiasami ostrymi.
Słowo kluczowe V[RGPCOG wprowadza do listy parametrów tzw. parametr typu (ang. type

24 Część I Podstawy

parameter). Jest to chyba najbardziej znany parametr szablonów języka C++ wykorzy-
stywany często w programach, nie jest jednak jedynym dopuszczalnym parametrem;
omówimy je nieco później (patrz rozdział 4.).

Nazwą parametru typu jest w naszym przykładzie 6. Nazwa ta mo e być dowolnym
ciągiem dopuszczalnym z punktu widzenia zasad konstruowania identyfikatorów języka
C++, dla parametru typu przyjęło się jednak stosować nazwę 6. Parametr typu reprezen-
tuje typ umowny precyzowany przez programistę dopiero w miejscu wywołania funkcji.
Wywołanie mo e określać dowolny typ (typ podstawowy, klasę itp.) pod warunkiem, e
dla tego typu zdefiniowane są wszystkie operacje wykorzystywane w szablonie funkcji.
W prezentowanym przykładzie typ ten musi więc obsługiwać operator relacji „mniejsze
ni ” (), poniewa parametry przekazywane do funkcji są porównywane właśnie za
pomocą tego operatora.

Z przyczyn historycznych w określeniu parametru typu dopuszcza się stosowanie w miej-
sce V[RGPCOG słowa kluczowego ENCUU. Słowo kluczowe V[RGPCOG pojawiło się w defini-
cji języka C++ stosunkowo późno; wcześniej jedynym sposobem wprowadzenia do listy
parametrów szablonu parametru typu było zastosowanie właśnie słowa kluczowego
ENCUU. Mo liwość ta została podtrzymana równie w ostatnich wersjach standardu C++.
Nasz szablon mo na więc równie dobrze zdefiniować jako:
VGORNCVG ENCUU 6
KPNKPG 6 EQPUV OCZ
6 EQPUV C 6 EQPUV D
]
TGVWTP C D ! D C
_

Definicja ta jest znaczeniowo to sama z definicją prezentowaną jako pierwszą. Nale y
przy tym pamiętać, e pomimo zastosowania słowa kluczowego ENCUU zakres dopusz-
czalnych typów parametrów szablonu nie jest redukowany do typów definiowanych
przez u ytkownika (klas). Widać więc, e stosowanie słowa kluczowego ENCUU mo e
być mylące (6 mo e przecie zostać zastąpione w wywołaniu równie przez typ pod-
stawowy), dlatego w przypadkach wątpliwych zaleca się stosowanie słowa kluczowego
V[RGPCOG. W miejsce słowa kluczowego V[RGPCOG nie mo na natomiast z dobrym skut-
kiem zastosować słowa kluczowego UVTWEV (choć jest on w pewnym zakresie to samy
ze słowem kluczowym ENCUU).

-QT[UVCPKG UCDNQPW
Poni szy program ilustruje sposób wykorzystania zdefiniowanego wcześniej szablonu
funkcji OCZ
:
RQFUVCY[OCZERR

KPENWFG KQUVTGCO
KPENWFG UVTKPI
KPENWFG OCZJRR

KPV OCKP

]
KPV K
UVFEQWV OCZ
K OCZ
K UVFGPFN

Rozdział 2. Szablony funkcji 25

FQWDNG H
FQWDNG H
UVFEQWV OCZ
H H OCZ
H H UVFGPFN

UVFUVTKPI U OCVGOCV[MC
UVFUVTKPI U OCVGOC
UVFEQWV OCZ
U U OCZ
U U UVFGPFN
_

W tym programie funkcja OCZ
została wywołana trzykrotnie: dla dwóch argumentów
typu KPV, dla dwóch argumentów typu FQWDNG oraz dla dwóch argumentów typu UVF
UVTKPI. Za ka dym razem funkcja zwróciła większą z dwóch przekazanych wartości.
Wydruk programu powinien wyglądać następująco:
OCZ
K
OCZ
H H
OCZ
U U OCVGOCV[MC

Zauwa my, e ka de z wywołań funkcji OCZ
zostało opatrzone operatorem zasięgu .
Dzięki niemu mamy gwarancję, e funkcja OCZ
będzie wyszukiwana w globalnej prze-
strzeni nazw programu. Istnieje bowiem równie szablon funkcji UVFOCZ
, który w pew-
nych warunkach mógłby zostać wywołany zamiast naszego szablonu OCZ
1.

Zazwyczaj szablony nie są kompilowane do postaci jednostek obsługujących typ do-
wolny. Dla ka dego nowego typu, dla którego wywołany zostanie szablon, generowana
jest osobna jednostka programowa2. Funkcja OCZ
zostanie więc skompilowana trzy-
krotnie, dla ka dego z typów, z którym została wywołana. Dla przykładu, pierwsze
wywołanie funkcji OCZ
:
KPV K
OCZ
K

oznacza takie odwołanie do szablonu funkcji, które określa parametr 6 jako KPV. Wy-
wołanie to odpowiada więc wywołaniu następującej funkcji:
KPNKPG KPV EQPUV OCZ
KPV EQPUV C KPV EQPUV D
]
TGVWTP C D ! D C
_

Proces zastępowania parametrów szablonu konkretnymi typami nazywamy konkretyza-
cją (ang. instantiation) szablonu. Jej efektem jest utworzenie egzemplarza (ang. instan-
ce) szablonu. Co prawda pojęcia egzemplarza i konkretyzacji w kontekście programo-
wania obiektowego stosowane są równie w odniesieniu do obiektów klas, jednak ze
względu na tematykę niniejszej ksią ki terminy te będziemy odnosić zawsze do szablo-
nów (o ile nie zaznaczymy inaczej).

1
Przykładowo, je eli typ jednego z parametrów wywołania zostanie zdefiniowany w przestrzeni nazw UVF
(jak choćby typ UVFUVTKPI), reguły wyszukiwania języka C++ spowodują dopasowanie w miejscu
wywołania obu szablonów globalnego OCZ
i UVFOCZ
.
2
Alternatywa, polegająca na generowaniu przez kompilator jednostek uniwersalnych, jest co prawda
do pomyślenia, ale w praktyce stosuje się ją rzadko. Wszystkie reguły języka oparte są na koncepcji
zakładającej generowanie osobnych jednostek dla ró nych typów szablonów.


Istotne jest, e konkretyzację wyzwala samo zastosowanie szablonu funkcji — progra-
mista nie musi jawnie ądać utworzenia egzemplarza szablonu.

Pozostałe wywołania OCZ
konkretyzują szablon OCZ
dla typów FQWDNG i UVFUVTKPI
i są wykorzystywane dokładnie tak, jakby specjalnie dla tych wywołań zostały zdefi-
niowane i zaimplementowane funkcje:
EQPUV FQWDNG OCZ
FQWDNG EQPUV FQWDNG EQPUV
EQPUV UVFUVTKPI OCZ
UVFUVTKPI EQPUV UVFUVTKPI EQPUV

Próba konkretyzacji szablonu dla typu, który nie obsługuje wszystkich operacji wyko-
rzystywanych w szablonie, sprowokuje błąd kompilacji. Przykład:
UVFEQORNGZHNQCV E E V[R EQORNGZ PKG QDU WIWLG QRGTCVQTC

OCZ
E E $ ä MQORKNCELK

Jak widać, szablony są kompilowane dwukrotnie:
Pierwszy raz bez konkretyzacji: kod szablonu jest analizowany pod kątem
poprawności składniowej. Na tym etapie wykrywane są błędy składniowe,
takie jak brakujące średniki.
Drugi raz podczas konkretyzacji: kod szablonu jest weryfikowany pod kątem
poprawności wszystkich wywołań. Na tym etapie wykrywane są niepoprawne
wywołania, takie jak wywołania funkcji nieobsługujące danego typu.

W praktyce dwukrotna kompilacja jest przyczyną dość istotnego problemu: kiedy sza-
blon funkcji jest wykorzystywany w sposób prowokujący jego konkretyzację, kompi-
lator (w pewnym momencie) musi odwołać się do definicji szablonu. Powoduje to naru-
szenie uświęconej wieloletnią tradycją języka C separacji pomiędzy etapem kompilacji
a etapem konsolidacji kodu funkcji, gdy normalnie do kompilacji wywołania funkcji
wystarczające jest jej uprzednie zadeklarowanie. W rozdziale 6. poka emy, jak poradzić
sobie z tym problemem. Na razie zaś wykorzystamy metodę najprostszą: implementację
ka dego szablonu w pliku nagłówkowym, za pomocą słowa kluczowego KPNKPG.

GFWMELC V[RW CTIWOGPVÎY
Wywołując szablon funkcji (jak OCZ
) z pewnymi argumentami, określamy za ich po-
średnictwem parametry szablonu. Je eli jako parametry 6 EQPUV przekazane zostaną
zmienne typu KPV, kompilator języka C++ zało y, e typem 6 jest typ KPV. Zauwa my,
e taki sposób wnioskowania o typie parametrów wyklucza stosowanie automatycznej
konwersji typów w miejscu wywołania szablonu funkcji. Ka dy typ 6 musi zostać okre-
ślony w sposób jawny. Oto przykład:
VGORNCVG V[RGPCOG 6
KPNKPG 6 EQPUV OCZ
6 EQPUV C 6 EQPUV D

OCZ
1$4' 6 VQ KPV FNC QDW CTIWOGPVÎY
OCZ
$ ä RKGTYU[ CTIWOGPV LGUV V[RW KPV FTWIK V[RW FQWDNG


Błąd ten mo na wyeliminować na trzy sposoby:
Przez jawne rzutowanie parametrów do wspólnego typu:
OCZ
UVCVKEAECUVFQWDNG
1$4'

Przez jawne określenie typu 6 w wywołaniu szablonu:
OCZFQWDNG

Przez zdefiniowanie szablonu o dwóch ró nych parametrach typu.

Szczegółowe omówienie ka dej z trzech metod znajduje się w kolejnym podrozdziale.

2CTCOGVT[ UCDNQPW
Szablony funkcji mo na zdefiniować przy u yciu dwóch rodzajów parametrów:
Parametrów szablonu, deklarowanych wewnątrz nawiasów ostrych przed nazwą
szablonu funkcji:
VGORNCVG V[RGPCOG 6 6 LGUV RCTCOGVTGO UCDNQPW

Parametrów wywołania, deklarowanych wewnątrz nawiasów zwykłych
po nazwie szablonu funkcji:
OCZ
6 EQPUV C 6 EQPUV D C K D Uæ RCTCOGVTCOK Y[YQ CPKC

Nie istnieje ograniczenie liczby parametrów szablonu. Niemniej jednak w szablonach
funkcji (w przeciwieństwie do szablonów klas) nie mo na zdefiniować domyślnych ar-
gumentów szablonu 3. Definicja szablonu OCZ
taka, aby w wywołaniu przyjmowane
były argumenty ró nych typów, wyglądałaby następująco:
VGORNCVG V[RGPCOG 6 V[RGPCOG 6
KPNKPG 6 OCZ
6 EQPUV C 6 EQPUV D
]
TGVWTP C D ! D C
_

OCZ
1$4' CNG V[R RKGTYUGIQ CTIWOGPVW FGVGTOKPWLG V[R YCTVQ EK YTCECPGL

Metoda polegająca na dopuszczeniu w wywołaniu parametrów ró nych typów wydaje
się skuteczna, ale skuteczność ta jest pozorna. Problem tkwi w typie wartości zwracanej
przez szablon funkcji. Je eli wartość ta będzie typu zgodnego z typem jednego z para-
metrów, argument drugiego typu będzie musiał zostać poddany konwersji do typu pierw-
szego, niezale nie od intencji programisty. Język C++ nie dysponuje bowiem metodami
pozwalającymi na wyznaczenie „lepszego” z dwóch typów (choć mo na tę mo liwość
zaimplementować przy u yciu pewnych sztuczek z szablonami, prezentowanymi w punk-
cie 15.2.4). Dlatego kolejność przekazywania argumentów wywołania OCZ
jako mak-
simum z wartości 42 i 66.66 mo emy otrzymać wartość 66.66 (typu FQWDNG) bądź 66

3
Ograniczenie to jest rezultatem zaszłości związanych z projektowaniem szablonów funkcji. Wydaje się, e
nie ma technicznych przeciwwskazań do implementacji takiej mo liwości w nowoczesnych kompilatorach
języka C++; w przyszłości mo liwość ta będzie najprawdopodobniej dostępna (patrz podrozdział 13.3).


(typu KPV). Inny problem to tworzenie lokalnego obiektu tymczasowego podczas kon-
wersji typu drugiego parametru — tak utworzonego obiektu nie mo na zwrócić przez
referencję4. W naszym przykładzie oznacza to konieczność modyfikacji definicji sza-
blonu tak, aby zwracał typ 6 zamiast 6 EQPUV .

Typy parametrów wywołania tworzone są na podstawie parametrów szablonu, więc pa-
rametry szablonu i parametry wywołania mo na zazwyczaj ze sobą powiązać. Wiązanie
takie nazywamy dedukcją argumentów szablonu funkcji. Mechanizm ten pozwala na
wywoływanie szablonów funkcji dokładnie tak jak funkcji „zwykłych”.

Tym niemniej mo liwa jest równie jawna konkretyzacja szablonu dla wskazanych typów:
VGORNCVG V[RGPCOG 6
KPNKPG 6 EQPUV OCZ
6 EQPUV C 6 EQPUV D

OCZFQWDNG
MQPMTGV[CELC LCYPC V[RW 6 FQ V[RW FQWDNG

W przypadkach, kiedy nie ma powiązania pomiędzy parametrami wywołania a parame-
trami szablonu i niemo liwe jest określenie parametrów szablonu, konieczne jest jawne
określenie argumentu szablonu w miejscu wywołania. Przykładowo, typ wartości zwra-
canej przez szablon funkcji mo na określić, wprowadzając do definicji szablonu trzeci
parametr szablonu:
VGORNCVG V[RGPCOG 6 V[RGPCOG 6 V[RGPCOG 46
KPNKPG 46 OCZ
6 EQPUV C 6 EQPUV D

Niemniej jednak dedukcja typu argumentów nie obejmuje typu wartości zwracanej5, a 46
nie występuje na liście typów parametrów wywołania funkcji. Nie mo na więc wyde-
dukować typu 46. W efekcie konieczne jest jawne określanie w miejscu wywołania peł-
nej listy parametrów szablonu. Przykład:
KPNKPG 46 OCZ
6 EQPUV C 6 EQPUV D

OCZKPV FQWDNG FQWDNG
1$4' CNG PKGY[IQFPKG

Pokazaliśmy jak dotąd przypadki, w których jawnie (w miejscu wywołania) określany
był albo ka dy, albo aden z argumentów szablonu. Mo liwe jest równie jawne określa-
nie jedynie pierwszych kilku argumentów — pozostałe zostaną wydedukowane. W ogól-
ności konieczne jest określenie wszystkich argumentów typów a do ostatniego argu-
mentu, którego typ nie mo e zostać określony niejawnie (przez dedukcję). Je eli więc
zmienimy kolejność na liście parametrów przykładowego szablonu, będziemy mogli wy-
woływać funkcję szablonu, podając jawnie wyłącznie typ wartości zwracanej:
KPNKPG 46 OCZ
6 EQPUV C 6 EQPUV D

OCZFQWDNG
1$4' V[R YCTVQ EK YTCECPGL VQ FQWDNG

4
Zwracanie wartości przez referencję nie jest dozwolone w przypadku obiektów lokalnych względem
funkcji, poniewa po wyjściu z funkcji obiekt ten przestanie istnieć.
5
Dedukcję mo na postrzegać jako część procesu rozstrzygania przecią enia — proces ten równie ignoruje
typy wartości zwracanych. Jedynym wyjątkiem jest typ zwracany składowych operatorów konwersji klasy.


W powy szym przykładzie wywołanie OCZFQWDNG określa w sposób jawny typ warto-
ści zwracanej przez funkcję; parametry 6 i 6 muszą zaś zostać wydedukowane na pod-
stawie argumentów wywołania (tu: KPV i FQWDNG).

Zauwa my, e kolejne przeróbki szablonu funkcji OCZ
nie zmieniają zasadniczo jego
funkcjonalności. Ju w przypadku wersji jednoparametrowej szablonu mo na określać
typ parametrów przekazywanych w wywołaniu (i typ wartości zwracanej), nawet w przy-
padku przekazania argumentów dwóch ró nych typów. Zaleca się więc maksymalne
upraszczanie szablonów — w kolejnych podrozdziałach korzystać będziemy z jednopa-
rametrowego szablonu funkcji OCZ
.

Proces dedukcji parametrów został szczegółowo omówiony w rozdziale 11.

2TGEKæ CPKG UCDNQPÎY HWPMELK
Podobnie jak to ma miejsce w przypadku zwykłych funkcji, szablony funkcji mogą być
przecią ane. Przecią anie oznacza mo liwość korzystania z ró nych definicji funkcji,
o tych samych nazwach. Kiedy nazwa ta zostanie wykorzystana w wywołaniu, kompi-
lator języka C++ podejmuje decyzję o wyborze funkcji do obsługi wywołania. Reguły
rządzące procesem decyzyjnym są dostatecznie skomplikowane i bez szablonów. W bie-
ącym podrozdziale omówimy przecią anie wykorzystujące szablony funkcji. Czytelnicy,
którym podstawowe reguły rozstrzygania przecią ania bez szablonów nie są znane, po-
winni zapoznać się z dodatkiem B, gdzie zostały one opisane w dość szczegółowy sposób.

Ilustracją przecią ania szablonu funkcji mo e być następujący, prosty program:
RQFUVCY[OCZERR

OCMUKOWO FYÎEJ YCTVQ EK V[RW KPV
KPNKPG KPV EQPUV OCZ
KPV EQPUV C KPV EQPUV D
]
TGVWTP C D ! D C
_

OCMUKOWO FYÎEJ YCTVQ EK FQYQNPGIQ V[RW
VGORNCVG V[RGPCOG 6
KPNKPG 6 EQPUV OCZ
6 EQPUV C 6 EQPUV D
]
TGVWTP C D ! D C
_

OCMUKOWO VTGEJ YCTVQ EK FQYQNPGIQ V[RW
VGORNCVG V[RGPCOG 6
KPNKPG 6 EQPUV OCZ
6 EQPUV C 6 EQPUV D 6 EQPUV E
]
TGVWTP OCZ
OCZ
C D E
_

KPV OCKP

]
OCZ
Y[YQ CPKG UCDNQPW RTGMCCPKGO VTGEJ CTIWOGPVÎY
OCZ
Y[YQ CPKG UCDNQPW OCZFQWDNG
FGFWMELC V[RW CTIWOGPVÎY


OCZ
C D Y[YQ CPKG UCDNQPW OCZFQWDNG
OCZ
Y[YQ CPKG HWPMELK Y[M GL FNC FYÎEJ CTIWOGPVÎY KPV
OCZ
Y[YQ CPKG UCDNQPW OCZKPV
OCZFQWDNG
DG FGFWMELK V[RW
OCZ
C Y[YQ CPKG HWPMELK Y[M GL FNC FYÎEJ CTIWOGPVÎY KPV
_

Jak widać, „zwykłe” funkcje mogą współistnieć z szablonami funkcji o tych samych na-
zwach i konkretyzowanych dla tych samych co owe zwykłe funkcje typów. Je eli wszyst-
kie pozostałe czynniki są identyczne, proces rozstrzygający przecią enia preferuje funk-
cje „zwykłe” przed szablonami. Sytuację tę ilustruje czwarte z kolei wywołanie:
OCZ
QDC CTIWOGPV[ QFRQYKCFCLæ HWPMELK Y[M GL

Je eli na podstawie szablonu mo na wygenerować lepsze dopasowanie, wybierany jest
oczywiście szablon. Przypadek taki miał miejsce w wywołaniach drugim i trzecim:
OCZ
OCZ
C D Y[YQ CPKG UCDNQPW OCZEJCT

Mo liwe jest równie jawne wskazanie pustej listy argumentów szablonu. W ten sposób
programista sygnalizuje konieczność wykorzystania szablonu, przy czym jego parame-
try powinny zostać wydedukowane na podstawie argumentów wywołania:
OCZ
Y[YQ CPKG UCDNQPW OCZKPV

Poniewa w przypadku szablonów funkcji nie jest wykonywana automatyczna konwer-
sja typu parametrów wywołania, ale konwersja taka jest przeprowadzana dla zwykłych
funkcji, ostatnie wywołanie dopasowane zostanie do funkcji zwykłej (parametry C i
zostaną poddane konwersji do typu KPV):
OCZ
C V[NMQ Y[M C HWPMELC FQRWUEC TÎ PG V[R[ CTIWOGPVÎY Y[YQ CPKC

Bardziej u ytecznym przykładem będzie przecią enie szablonu zwracającego maksi-
mum tak, aby obsługiwał on wskaźniki i ciągi znakowe języka C:
RQFUVCY[OCZERR

KPENWFG KQUVTGCO
KPENWFG EUVTKPI
KPENWFG UVTKPI

OCMUKOWO FYÎEJ YCTVQ EK FQYQNPGIQ V[RW
VGORNCVG V[RGPCOG 6
KPNKPG 6 EQPUV OCZ
6 EQUV C 6 EQPUV D
]
TGVWTP C D ! D C
_

OCMUKOWO FYÎEJ YUMC PKMÎY
VGORNCVG V[RGPCOG 6
KPNKPG 6

C++. Szablony. Vademecum profesjonalisty

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Mehr von Wydawnictwo Helion

Mehr von Wydawnictwo Helion (20)

C++. Szablony. Vademecum profesjonalisty