Professional Documents
Culture Documents
PRZYKADOWY ROZDZIA
SPIS TRECI
KATALOG KSIEK
KATALOG ONLINE
ZAMW DRUKOWANY KATALOG
TWJ KOSZYK
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMW INFORMACJE
O NOWOCIACH
ZAMW CENNIK
CZYTELNIA
FRAGMENTY KSIEK ONLINE
C++. Szablony.
Vademecum
profesjonalisty
Autorzy: David Vandevoorde, Nicolai M. Josuttis
Tumaczenie: Przemysaw Szeremiota
ISBN: 83-7361-175-4
Tytu oryginau: C++ Templates The Complete Guide
Format: B5, stron: 474
Cho szablony s czci definicji jzyka C++ od ponad dziesiciu lat, wci s rdem
nieporozumie, omyek i kontrowersji. Z drugiej strony, ich popularno jako
efektywnych instrumentw tworzenia bardziej eleganckiego, szybszego
i inteligentniejszego oprogramowania stale ronie. W rzeczy samej, szablony
osigny rang kamieni wgielnych dla kilku nowych modeli programowania
w jzyku C++.
Ksika "C++. Szablony. Vademecum profesjonalisty." zawiera komplet informacji
niezbdnych do rozpoczcia korzystania z szablonw i penego wykorzystania ich
moliwoci, jak rwnie wiedzy pomagajcej dowiadczonym programistom
przekroczy granic, za ktr programowanie z rzemiosa staje si sztuk. Autorzy
zaoyli, e znasz jzyk C++ i potrafisz programowa z wykorzystaniem komponentw
biblioteki standardowej. Prezentowane w ksice przykady znakomicie ilustruj
abstrakcyjne pojcia i demonstruj najlepsze praktyki programistyczne.
Poznasz:
sposoby unikania puapek towarzyszcych stosowaniu szablonw,
idiomy i techniki zwizane z szablonami -- od technik najprostszych do takich,
ktre poza t ksik nie zostay jeszcze nigdzie dokumentowane,
sposoby wielokrotnego wykorzystywania tego samego kodu rdowego
bez zmniejszania jego wydajnoci i bezpieczestwa,
sposoby zwikszania efektywnoci programw w jzyku C++,
sposoby tworzenia oprogramowania bardziej elastycznego i atwiejszego
w utrzymaniu.
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
5RKUVTGEK
Rozdzia 1.
1.1. Co naley wiedzie przed przystpieniem do lektury? ............................................. 16
1.2. Struktura oglna ksiki ....................................................................................... 16
1.3. Jak czyta t ksik?........................................................................................... 17
1.4. Uwagi do stosowanego w tekcie stylu programowania ........................................... 17
1.5. Standard a rzeczywisto ...................................................................................... 19
1.6. Pliki przykadw i dodatkowe informacje............................................................... 20
Rozdzia 2.
2.1. Szablony funkcji wstp .................................................................................... 23
2.1.1. Definiowanie szablonu ................................................................................. 23
2.1.2. Korzystanie z szablonu ................................................................................ 24
2.2. Dedukcja typu argumentw .................................................................................. 26
2.3. Parametry szablonu.............................................................................................. 27
2.4. Przecianie szablonw funkcji ............................................................................. 29
2.5. Podsumowanie .................................................................................................... 33
Rozdzia 3.
3.1. Implementacja szablonu klasy Stack ...................................................................... 35
3.1.1. Deklarowanie szablonw klas ....................................................................... 36
3.1.2. Implementacja metod klasy .......................................................................... 37
3.2. Korzystanie z szablonu klasy Stack ....................................................................... 38
3.3. Specjalizacje szablonw klas................................................................................. 40
3.4. Specjalizacja czciowa........................................................................................ 42
3.5. Domylne argumenty szablonu.............................................................................. 43
3.6. Podsumowanie .................................................................................................... 45
Rozdzia 4.
"#
4.1. Pozatypowe parametry szablonw klas .................................................................. 47
4.2. Pozatypowe parametry szablonw funkcji .............................................................. 50
4.3. Ograniczenia dla pozatypowych parametrw szablonw.......................................... 51
4.4. Podsumowanie .................................................................................................... 52
Rozdzia 5.
$
5.1. Sowo kluczowe typename ................................................................................... 53
5.2. Zastosowanie odwoania this> ............................................................................. 55
5.3. Szablony skadowych ........................................................................................... 55
Rozdzia 6.
%&
6.1. Model wczania.................................................................................................. 69
6.1.1. Komunikaty o bdach konsolidacji ............................................................... 69
6.1.2. Szablony w plikach nagwkowych ............................................................... 71
6.2. Konkretyzacja jawna............................................................................................ 72
6.2.1. Przykad konkretyzacji jawnej ...................................................................... 73
6.2.2. Poczenie modelu wczania i konkretyzacji jawnej....................................... 74
6.3. Model separacji ................................................................................................... 75
6.3.1. Sowo kluczowe export ................................................................................ 75
6.3.2. Ograniczenia modelu separacji...................................................................... 77
6.3.3. Przygotowanie do wykorzystania modelu separacji......................................... 78
6.4. Szablony a sowo kluczowe inline ......................................................................... 79
6.5. Wstpna kompilacja plikw nagwkowych ........................................................... 79
6.6. Diagnostyka szablonw ........................................................................................ 82
6.6.1. Dekodowanie elaboratu o bdzie .................................................................. 82
6.6.2. Konkretyzacja pytka ................................................................................... 84
6.6.3. Zbyt dugie symbole .................................................................................... 86
6.6.4. Tropiciele ................................................................................................... 86
6.6.5. Wyrocznie .................................................................................................. 90
6.6.6. Archetypy................................................................................................... 91
6.7. Uwagi kocowe ................................................................................................... 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. Regua pojedynczej definicji ................................................................................. 95
7.5. Parametry czy argumenty szablonw?.................................................................... 96
Rozdzia 8.
*
8.1. Deklaracje sparametryzowane............................................................................. 101
8.1.1. Wirtualne funkcje skadowe........................................................................ 104
8.1.2. czenie szablonw................................................................................... 104
8.1.3. Szablony podstawowe................................................................................ 105
8.2. Parametry szablonw ......................................................................................... 105
8.2.1. Parametry typw ....................................................................................... 106
8.2.2. Parametry pozatypowe............................................................................... 106
8.2.3. Szablony parametrw szablonw ................................................................ 107
8.2.4. Domylne argumenty szablonw................................................................. 108
8.3. Argumenty szablonu .......................................................................................... 109
8.3.1. Argumenty szablonw funkcji .................................................................... 110
8.3.2. Argumenty typw...................................................................................... 112
8.3.3. Argumenty pozatypowe ............................................................................. 113
8.3.4. Argumenty szablonw parametrw szablonw ............................................. 115
8.3.5. Rwnowano argumentw ...................................................................... 117
Spis treci
Rozdzia 9.
+ ,
9.1. Taksonomia nazw .............................................................................................. 123
9.2. Wyszukiwanie nazw........................................................................................... 125
9.2.1. Wyszukiwanie wedug argumentw ............................................................ 126
9.2.2. Wtrcanie nazw zaprzyjanionych .............................................................. 128
9.2.3. Wtrcane nazwy klas ................................................................................. 129
9.3. Analiza skadniowa szablonw............................................................................ 130
9.3.1. Wraliwo kontekstowa poza szablonami ................................................... 130
9.3.2. Zalene nazwy typw ................................................................................ 133
9.3.3. Zalene nazwy szablonw .......................................................................... 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 kocowe ................................................................................................. 141
Rozdzia 10.
$
"
10.1. Konkretyzacja na danie ................................................................................. 143
10.2. Konkretyzacja opniona.................................................................................. 145
10.3. Model konkretyzacji z jzyku C++ .................................................................... 147
10.3.1. Wyszukiwanie dwufazowe ....................................................................... 148
10.3.2. Punkty konkretyzacji................................................................................ 148
10.3.3. Modele wczania i separacji..................................................................... 151
10.3.4. Wyszukiwanie pomidzy jednostkami translacji ......................................... 152
10.3.5. Przykady................................................................................................ 153
10.4. Schematy implementacji ................................................................................... 154
10.4.1. Konkretyzacja zachanna .......................................................................... 156
10.4.2. Konkretyzacja z baz danych.................................................................... 157
10.4.3. Konkretyzacja iterowana .......................................................................... 159
10.5. Konkretyzacja jawna........................................................................................ 161
10.6. Uwagi kocowe ............................................................................................... 165
Rozdzia 11.
%#
11.1. Proces dedukcji................................................................................................ 167
11.2. Konteksty dedukowane .................................................................................... 169
11.3. Sytuacje wyjtkowe procesu dedukcji ................................................................ 171
11.4. Dopuszczalne konwersje argumentw................................................................ 172
11.5. Parametry szablonw klas................................................................................. 173
11.6. Domylne argumenty wywoania ....................................................................... 173
11.7. Technika Bartona-Nackmana ............................................................................ 174
11.8. Uwagi kocowe ............................................................................................... 176
Rozdzia 12.
##
12.1. Kiedy kod uoglniony nie jest odpowiedni?........................................................ 177
12.1.1. Przezroczysto dopasowania ................................................................... 178
12.1.2. Przezroczysto semantyczna ................................................................... 179
12.2. Przecianie szablonw funkcji ......................................................................... 180
12.2.1. Sygnatury ............................................................................................... 181
12.2.2. Porzdkowanie czciowe przecionych szablonw funkcji ....................... 183
Rozdzia 13.
$
*
13.1. Problem nawiasw ostrych ............................................................................... 201
13.2. Lune reguy deklaracji typename...................................................................... 202
13.3. Domylne argumenty szablonw funkcji ............................................................ 203
13.4. Literay acuchowe i zmiennoprzecinkowe jako argumenty szablonw ................ 204
13.5. Lune dopasowanie szablonw parametrw szablonw ....................................... 206
13.6. Szablony definicji typu ..................................................................................... 207
13.7. Specjalizacja czciowa szablonw funkcji......................................................... 209
13.8. Operator typeof ............................................................................................... 210
13.9. Nazwane argumenty szablonu ........................................................................... 212
13.10. Waciwoci statyczne typw .......................................................................... 213
13.11. Wasna diagnostyka konkretyzacji ................................................................... 213
13.12. Przecione szablony klas ............................................................................... 216
13.13. Parametry wielokrotne .................................................................................... 216
13.14. Kontrola rozmieszczenia w pamici ................................................................. 218
13.15. Dedukcja typu na podstawie inicjalizatora ........................................................ 219
13.16. Wyraenia funkcyjne...................................................................................... 220
13.17. Uwagi kocowe ............................................................................................. 222
14.1. Polimorfizm dynamiczny .................................................................................. 225
14.2. Polimorfizm statyczny...................................................................................... 228
14.3. Polimorfizm statyczny kontra dynamiczny ......................................................... 230
14.4. Nowe formy wzorcw projektowych ................................................................. 232
14.5. Programowanie oglne ..................................................................................... 233
14.6. Uwagi kocowe ............................................................................................... 235
Rozdzia 15.
$ ,,
#
15.1. Przykad kumulowanie cigu elementw........................................................ 237
15.1.1. Cechy ustalone ........................................................................................ 238
15.1.2. Cechy wartoci ........................................................................................ 241
15.1.3. Parametryzacja cech ................................................................................ 244
15.1.4. Wytyczne i klasy wytycznych ................................................................... 246
15.1.5. Czym rni si cechy i wytyczne? ........................................................... 248
15.1.6. Szablony skadowe a szablony parametrw szablonw................................ 249
15.1.7. czenie wielu cech i wytycznych............................................................. 251
15.1.8. Kumulowanie za pomoc iteratorw oglnych............................................ 251
15.2. Funkcje typw................................................................................................. 252
15.2.1. Okrelanie typu elementu ......................................................................... 253
15.2.2. Okrelanie typu definiowanego przez uytkownika ..................................... 255
15.2.3. Referencje i kwalifikatory......................................................................... 257
15.2.4. Cechy promocji ....................................................................................... 259
Spis treci
Rozdzia 16.
#
16.1. Nazwane argumenty szablonw......................................................................... 271
16.2. Optymalizacja pustej klasy bazowej................................................................... 274
16.2.1. Zasady rozmieszczania klas w pamici ...................................................... 275
16.2.2. Klasy bazowe w postaci skadowych ......................................................... 277
16.3. Wzorzec CRTP................................................................................................ 279
16.4. Parametryzacja wirtualnoci metod.................................................................... 281
16.5. Uwagi kocowe ............................................................................................... 282
Rozdzia 17.
/ )
0
17.1. Metaprogram pierwsza odsona..................................................................... 285
17.2. Wartoci wyliczeniowe a stae statyczne ............................................................ 287
17.3. Przykad drugi obliczanie pierwiastka kwadratowego...................................... 288
17.4. Zmienne indukowane ....................................................................................... 292
17.5. Zupeno obliczeniowa.................................................................................... 295
17.6. Konkretyzacja rekurencyjna a rekurencyjne argumenty szablonw ....................... 296
17.7. Metaprogramowanie w rozwijaniu ptli.............................................................. 297
17.8. Uwagi kocowe ............................................................................................... 300
Rozdzia 18.
1
*
18.1. Obiekty tymczasowe i rozdzielanie ptli............................................................. 304
18.2. Kodowanie wyrae obliczeniowych za pomoc argumentw szablonw.............. 308
18.2.1. Operandy szablonw wyrae................................................................... 309
18.2.2. Typ Array ............................................................................................... 312
18.2.3. Operatory ............................................................................................... 314
18.2.4. Podsumowanie ........................................................................................ 315
18.2.5. Przypisania szablonw wyrae ................................................................ 317
18.3. Wydajno szablonw wyrae i ich ograniczenia............................................... 318
18.4. Uwagi kocowe ............................................................................................... 319
$ !
19.1. Identyfikowanie typw podstawowych............................................................... 325
19.2. Identyfikowanie typw zoonych...................................................................... 327
19.3. Identyfikowanie typw funkcyjnych .................................................................. 329
19.4. Klasyfikacja typw wyliczeniowych przez rozstrzyganie przecienia .................. 333
19.5. Identyfikowanie typw definiowanych przez uytkownika................................... 335
19.6. Jak to wszystko poczy? ................................................................................ 336
19.7. Uwagi kocowe ............................................................................................... 338
Rozdzia 20.
2) 3
"
20.1. Posiadacze i kuriery ......................................................................................... 341
20.1.1. Ochrona przed wyjtkami......................................................................... 342
20.1.2. Klasa posiadacza ..................................................................................... 343
20.1.3. Posiadacze jako skadowe......................................................................... 346
20.1.4. Pozyskiwanie zasobw w inicjalizacji........................................................ 347
20.1.5. Ograniczenia klasy posiadacza .................................................................. 348
10
Rozdzia 21.
$
%&
21.1. Duety.............................................................................................................. 369
21.2. Duety rekurencyjne.......................................................................................... 374
21.2.1. Liczba pl duetw rekurencyjnych ............................................................ 374
21.2.2. Typy pl duetw rekurencyjnych .............................................................. 375
21.2.3. Wartoci pl duetw rekurencyjnych......................................................... 376
21.3. Konstruowanie krotek ...................................................................................... 380
21.4. Uwagi kocowe ............................................................................................... 384
Rozdzia 22.
0
22.1. Wywoania bezporednie, porednie i rozwijane w miejscu wywoania ................. 386
22.2. Wskaniki i referencje do funkcji ...................................................................... 389
22.3. Wskaniki do metod......................................................................................... 391
22.4. Funktory typw definiowanych przez uytkownika ............................................. 394
22.4.1. Pierwszy przykad funktora typu definiowanego przez uytkownika............. 394
22.4.2. Typy funktorw typw definiowanych przez uytkownika........................... 395
22.5. Przekazywanie funktorw................................................................................. 397
22.5.1. Funktory jako argumenty typu szablonw .................................................. 397
22.5.2. Funktory jako argumenty wywoania funkcji .............................................. 398
22.5.3. Poczenie parametrw wywoania funkcji z parametrami typu szablonu ...... 399
22.5.4. Funktory jako pozatypowe argumenty szablonw ....................................... 399
22.5.5. Kapsukowanie wskanika do funkcji ........................................................ 400
22.6. Introspekcja..................................................................................................... 403
22.6.1. Analiza typu funktora............................................................................... 403
22.6.2. Dostp do parametrw typw ................................................................... 404
22.6.3. Kapsukowanie wskanikw do funkcji...................................................... 406
22.7. Skadanie obiektu funkcyjnego .......................................................................... 410
22.7.1. Zoenie proste ........................................................................................ 411
22.7.2. Skadanie funktorw mieszanych typw .................................................... 414
22.7.3. Zmniejszanie liczby parametrw ............................................................... 417
22.8. Wizania wartoci ............................................................................................ 420
22.8.1. Wybr wizania....................................................................................... 420
22.8.2. Sygnatura wizania .................................................................................. 422
22.8.3. Wybr argumentw ................................................................................. 423
22.8.4. Funkcje pomocnicze ................................................................................ 428
22.9. Operacje na funktorach pena implementacja.................................................. 430
22.10. Uwagi kocowe ............................................................................................. 433
Spis treci
11
#
$%
Dodatek A
4).
"#
A.1. Jednostki translacji ............................................................................................ 437
A.2. Deklaracje i definicje......................................................................................... 438
A.3. Regua 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. Rwnowano definicji pomidzy jednostkami translacji ............................ 443
Dodatek B
""&
B.1. Kiedy potrzebne jest rozstrzyganie przecienia? ................................................. 450
B.2. Uproszczone rozstrzyganie przecienia .............................................................. 450
B.2.1. Niejawny argument metod ......................................................................... 452
B.2.2. Doskonalenie idealnego dopasowania ......................................................... 454
B.3. Przecianie z bliska.......................................................................................... 455
B.3.1. Dyskryminacja szablonw ......................................................................... 455
B.3.2. Sekwencje konwersji................................................................................. 456
B.3.3. Konwersje wskanikw ............................................................................. 456
B.3.4. Funktory i funkcje zastpcze...................................................................... 458
B.3.5. Inne konteksty przeciania ....................................................................... 459
Dodatek C
5)
"%
Grupy dyskusyjne .................................................................................................... 461
Ksiki i witryny WWW........................................................................................... 462
"%
Rozdzia 2.
5\CDNQP[HWPMELK
W rozdziale tym wprowadzimy pojcie szablonu funkcji. Szablony funkcji to funkcje
sparametryzowane tak, aby mogy reprezentowa cae rodziny funkcji.
Szablony funkcji definiuj kod, ktry moe by realizowany dla rnych typw danych.
Innymi sowy, szablon funkcji reprezentuje rodzin funkcji. Reprezentacja ta przypomina zwyk funkcj jzyka C++, pozbawion tylko cisego okrelenia niektrych elementw. Elementy te s wic sparametryzowane. Najlepiej wytumaczymy to na prostym
przykadzie.
Poniszy kod stanowi deklaracj szablonu funkcji zwracajcej wiksz z dwu przekazanych do niej wartoci:
!"#
$% !"
% &'#
(
Szablon ten definiuje rodzin funkcji, ktre zwracaj wiksz z dwu przekazanych do
nich wartoci (przekazanie odbywa si za porednictwem parametrw wywoania funkcji: i ). Typ parametrw funkcji nie zosta jawnie okrelony i wystpuje w szablonie
jako parametr szablonu . Przykad pokazuje, e parametry szablonw musz zosta
podane w ramach nastpujcej konstrukcji skadniowej:
NKUVCRCTCOGVTYQFF\KGNCP[EJRT\GEKPMCOK
24
Cz I Podstawy
parameter). Jest to chyba najbardziej znany parametr szablonw jzyka C++ wykorzystywany czsto w programach, nie jest jednak jedynym dopuszczalnym parametrem;
omwimy je nieco pniej (patrz rozdzia 4.).
Nazw parametru typu jest w naszym przykadzie . Nazwa ta moe by dowolnym
cigiem dopuszczalnym z punktu widzenia zasad konstruowania identyfikatorw jzyka
C++, dla parametru typu przyjo si jednak stosowa nazw . Parametr typu reprezentuje typ umowny precyzowany przez programist dopiero w miejscu wywoania funkcji.
Wywoanie moe okrela dowolny typ (typ podstawowy, klas itp.) pod warunkiem, e
dla tego typu zdefiniowane s wszystkie operacje wykorzystywane w szablonie funkcji.
W prezentowanym przykadzie typ ten musi wic obsugiwa operator relacji mniejsze
ni (<), poniewa parametry przekazywane do funkcji s porwnywane wanie za
pomoc tego operatora.
Z przyczyn historycznych w okreleniu parametru typu dopuszcza si stosowanie w miejsce sowa kluczowego
. Sowo kluczowe pojawio si w definicji jzyka C++ stosunkowo pno; wczeniej jedynym sposobem wprowadzenia do listy
parametrw szablonu parametru typu byo zastosowanie wanie sowa kluczowego
. Moliwo ta zostaa podtrzymana rwnie w ostatnich wersjach standardu C++.
Nasz szablon mona wic rwnie dobrze zdefiniowa jako:
!"#
$% !"
% &'#
(
Poniszy program ilustruje sposb wykorzystania zdefiniowanego wczeniej szablonu
funkcji :
)%
)% *
)%+
+
,-.#
''%+/'+''/''#
25
%01,2
-#
%0.,34
/#
''%+010.'+''010.''#
'' *1,+
$+#
'' *.,++#
''%+1.'+''1.''#
(
W tym programie funkcja zostaa wywoana trzykrotnie: dla dwch argumentw
typu , dla dwch argumentw typu oraz dla dwch argumentw typu
. Za kadym razem funkcja zwrcia wiksz z dwch przekazanych wartoci.
Wydruk programu powinien wyglda nastpujco:
/'-.
010.'-.
1.'
$
Zauwamy, e kade z wywoa funkcji zostao opatrzone operatorem zasigu .
Dziki niemu mamy gwarancj, e funkcja bdzie wyszukiwana w globalnej przestrzeni nazw programu. Istnieje bowiem rwnie szablon funkcji
, ktry w pewnych warunkach mgby zosta wywoany zamiast naszego szablonu 1.
Zazwyczaj szablony nie s kompilowane do postaci jednostek obsugujcych typ dowolny. Dla kadego nowego typu, dla ktrego wywoany zostanie szablon, generowana
jest osobna jednostka programowa2. Funkcja zostanie wic skompilowana trzykrotnie, dla kadego z typw, z ktrym zostaa wywoana. Dla przykadu, pierwsze
wywoanie funkcji :
,-.#
5/5
oznacza takie odwoanie do szablonu funkcji, ktre okrela parametr jako . Wywoanie to odpowiada wic wywoaniu nastpujcej funkcji:
!"#
$% !"
% &'#
(
Proces zastpowania parametrw szablonu konkretnymi typami nazywamy konkretyzacj (ang. instantiation) szablonu. Jej efektem jest utworzenie egzemplarza (ang. instance) szablonu. Co prawda pojcia egzemplarza i konkretyzacji w kontekcie programowania obiektowego stosowane s rwnie w odniesieniu do obiektw klas, jednak ze
wzgldu na tematyk niniejszej ksiki terminy te bdziemy odnosi zawsze do szablonw (o ile nie zaznaczymy inaczej).
1
Przykadowo, jeeli typ jednego z parametrw wywoania zostanie zdefiniowany w przestrzeni nazw
(jak choby typ '' *), reguy wyszukiwania jzyka C++ spowoduj dopasowanie w miejscu
wywoania obu szablonw globalnego i ''.
Alternatywa, polegajca na generowaniu przez kompilator jednostek uniwersalnych, jest co prawda
do pomylenia, ale w praktyce stosuje si j rzadko. Wszystkie reguy jzyka oparte s na koncepcji
zakadajcej generowanie osobnych jednostek dla rnych typw szablonw.
26
Cz I Podstawy
Istotne jest, e konkretyzacj wyzwala samo zastosowanie szablonu funkcji programista nie musi jawnie da utworzenia egzemplarza szablonu.
Pozostae wywoania konkretyzuj szablon dla typw i
i s wykorzystywane dokadnie tak, jakby specjalnie dla tych wywoa zostay zdefiniowane i zaimplementowane funkcje:
%%%#
'' *'' *'' *#
Prba konkretyzacji szablonu dla typu, ktry nie obsuguje wszystkich operacji wykorzystywanych w szablonie, sprowokuje bd kompilacji. Przykad:
''01.#
6%*%
5
1.#789:$
Pierwszy raz bez konkretyzacji: kod szablonu jest analizowany pod ktem
poprawnoci skadniowej. Na tym etapie wykrywane s bdy skadniowe,
takie jak brakujce redniki.
Drugi raz podczas konkretyzacji: kod szablonu jest weryfikowany pod ktem
poprawnoci wszystkich wywoa. Na tym etapie wykrywane s niepoprawne
wywoania, takie jak wywoania funkcji nieobsugujce danego typu.
W praktyce dwukrotna kompilacja jest przyczyn do istotnego problemu: kiedy szablon funkcji jest wykorzystywany w sposb prowokujcy jego konkretyzacj, kompilator (w pewnym momencie) musi odwoa si do definicji szablonu. Powoduje to naruszenie uwiconej wieloletni tradycj jzyka C separacji pomidzy etapem kompilacji
a etapem konsolidacji kodu funkcji, gdy normalnie do kompilacji wywoania funkcji
wystarczajce jest jej uprzednie zadeklarowanie. W rozdziale 6. pokaemy, jak poradzi
sobie z tym problemem. Na razie za wykorzystamy metod najprostsz: implementacj
kadego szablonu w pliku nagwkowym, za pomoc sowa kluczowego .
27
!
Szablony funkcji mona zdefiniowa przy uyciu dwch rodzajw parametrw:
Ograniczenie to jest rezultatem zaszoci zwizanych z projektowaniem szablonw funkcji. Wydaje si, e
nie ma technicznych przeciwwskaza do implementacji takiej moliwoci w nowoczesnych kompilatorach
jzyka C++; w przyszoci moliwo ta bdzie najprawdopodobniej dostpna (patrz podrozdzia 13.3).
28
Cz I Podstawy
(typu ). Inny problem to tworzenie lokalnego obiektu tymczasowego podczas konwersji typu drugiego parametru tak utworzonego obiektu nie mona zwrci przez
referencj4. W naszym przykadzie oznacza to konieczno modyfikacji definicji szablonu tak, aby zwraca typ zamiast
.
Typy parametrw wywoania tworzone s na podstawie parametrw szablonu, wic parametry szablonu i parametry wywoania mona zazwyczaj ze sob powiza. Wizanie
takie nazywamy dedukcj argumentw szablonu funkcji. Mechanizm ten pozwala na
wywoywanie szablonw funkcji dokadnie tak jak funkcji zwykych.
Tym niemniej moliwa jest rwnie jawna konkretyzacja szablonu dla wskazanych typw:
#
5
%--
.#$$
%
%%
W przypadkach, kiedy nie ma powizania pomidzy parametrami wywoania a parametrami szablonu i niemoliwe jest okrelenie parametrw szablonu, konieczne jest jawne
okrelenie argumentu szablonu w miejscu wywoania. Przykadowo, typ wartoci zwracanej przez szablon funkcji mona okreli, wprowadzajc do definicji szablonu trzeci
parametr szablonu:
1
.
<
<1.#
Niemniej jednak dedukcja typu argumentw nie obejmuje typu wartoci zwracanej5, a
nie wystpuje na licie typw parametrw wywoania funkcji. Nie mona wic wydedukowa typu . W efekcie konieczne jest jawne okrelanie w miejscu wywoania penej listy parametrw szablonu. Przykad:
1
.
<
<1.#
5
%%--
.#:;7<=>
*
Zwracanie wartoci przez referencj nie jest dozwolone w przypadku obiektw lokalnych wzgldem
funkcji, poniewa po wyjciu z funkcji obiekt ten przestanie istnie.
Dedukcj mona postrzega jako cz procesu rozstrzygania przecienia proces ten rwnie ignoruje
typy wartoci zwracanych. Jedynym wyjtkiem jest typ zwracany skadowych operatorw konwersji klasy.
29
W powyszym przykadzie wywoanie okrela w sposb jawny typ wartoci zwracanej przez funkcj; parametry i musz za zosta wydedukowane na podstawie argumentw wywoania (tu: i ).
Zauwamy, e kolejne przerbki szablonu funkcji nie zmieniaj zasadniczo jego
funkcjonalnoci. Ju w przypadku wersji jednoparametrowej szablonu mona okrela
typ parametrw przekazywanych w wywoaniu (i typ wartoci zwracanej), nawet w przypadku przekazania argumentw dwch rnych typw. Zaleca si wic maksymalne
upraszczanie szablonw w kolejnych podrozdziaach korzysta bdziemy z jednoparametrowego szablonu funkcji .
Proces dedukcji parametrw zosta szczegowo omwiony w rozdziale 11.
"!#$
Podobnie jak to ma miejsce w przypadku zwykych funkcji, szablony funkcji mog by
przeciane. Przecianie oznacza moliwo korzystania z rnych definicji funkcji,
o tych samych nazwach. Kiedy nazwa ta zostanie wykorzystana w wywoaniu, kompilator jzyka C++ podejmuje decyzj o wyborze funkcji do obsugi wywoania. Reguy
rzdzce procesem decyzyjnym s dostatecznie skomplikowane i bez szablonw. W biecym podrozdziale omwimy przecianie wykorzystujce szablony funkcji. Czytelnicy,
ktrym podstawowe reguy rozstrzygania przeciania bez szablonw nie s znane, powinni zapozna si z dodatkiem B, gdzie zostay one opisane w do szczegowy sposb.
Ilustracj przeciania szablonu funkcji moe by nastpujcy, prosty program:
.
$% ! A
%
% &'#
(
$% ! A *
%
% &'#
(
$% A *
%
% #
(
''/-.4B#
6% $ *%!
''/
C-.
C#
6%%%$
% *%!
30
Cz I Podstawy
''DDDD#
6%%%$
% *%!
''/-.#
60%$
$6 ! *%!
''/-.#
6%%$
% *%!
''%/-.#
6%%%$
%
''DD-.
/#
60%$
$6 ! *%!
(
Jak wida, zwyke funkcje mog wspistnie z szablonami funkcji o tych samych nazwach i konkretyzowanych dla tych samych co owe zwyke funkcje typw. Jeeli wszystkie pozostae czynniki s identyczne, proces rozstrzygajcy przecienia preferuje funkcje zwyke przed szablonami. Sytuacj t ilustruje czwarte z kolei wywoanie:
/-.# *%
@0%$
$6
Moliwe jest rwnie jawne wskazanie pustej listy argumentw szablonu. W ten sposb
programista sygnalizuje konieczno wykorzystania szablonu, przy czym jego parametry powinny zosta wydedukowane na podstawie argumentw wywoania:
/-.#
6%%$
% *%!
Poniewa w przypadku szablonw funkcji nie jest wykonywana automatyczna konwersja typu parametrw wywoania, ale konwersja taka jest przeprowadzana dla zwykych
funkcji, ostatnie wywoanie dopasowane zostanie do funkcji zwykej (parametry i !
zostan poddane konwersji do typu ):
DD-.
/#
$
$60%$% !
*%!
6
Bardziej uytecznym przykadem bdzie przecienie szablonu zwracajcego maksimum tak, aby obsugiwa on wskaniki i cigi znakowe jzyka C:
2
)%
)% *
)% *
$% ! A *
%
% &'#
(
$% ! $E$!
FFF
% FF&'#
(
31
32
Cz I Podstawy
% #6@$
$
A"
(
''/-.4B#:;7<=>
F1,+K +#
F.,+L+#
F2,+M%+#
''1.2#789:
(
33
%!
Szablony funkcji definiuj rodzin funkcji dla rnych parametrw szablonu.
Przekazujc w wywoaniu argumenty szablonu, konkretyzujemy szablon funkcji
parametrw szablonu.
Zawsze warto sprawdzi, czy w miejscu wywoania znane s wszystkie wersje