You are on page 1of 19

IDZ DO

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

Niektre z technik przestawionych w C++. Szablony. Vademecum profesjonalisty


nie doczekay si jeszcze opracowania w innych publikacjach. Jeli w programowaniu
w C++ chcesz osign najwyszy poziom, nie obdziesz si bez tej ksiki.

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

C++. Szablony. Vademecum profesjonalisty

5.4. Szablony parametrw szablonw........................................................................... 59


5.5. Inicjalizacja zerowa.............................................................................................. 63
5.6. Literay acuchowe jako argumenty szablonw funkcji .......................................... 64
5.7. Podsumowanie .................................................................................................... 67

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

8.4. Deklaracje zaprzyjanione .................................................................................. 117


8.4.1. Funkcje zaprzyjanione.............................................................................. 118
8.4.2. Szablony jednostek zaprzyjanionych.......................................................... 120
8.5. Uwagi kocowe ................................................................................................. 121

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

C++. Szablony. Vademecum profesjonalisty

12.2.3. Formalne reguy porzdkowania................................................................ 184


12.2.4. Szablony funkcji a funkcje zwyke ............................................................ 186
12.3. Specjalizacja jawna .......................................................................................... 187
12.3.1. Pena specjalizacja szablonu klasy ............................................................. 187
12.3.2. Pena specjalizacja szablonu funkcji .......................................................... 191
12.3.3. Pena specjalizacja skadowej.................................................................... 193
12.4. Czciowa specjalizacja szablonu klasy.............................................................. 195
12.5. Uwagi kocowe ............................................................................................... 198

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

        


Rozdzia 14.

.   !


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

15.3. Cechy wytycznych........................................................................................... 262


15.3.1. Parametry typw tylko do odczytu ............................................................ 263
15.3.2. Kopiowanie, wymiana i przenoszenie ........................................................ 266
15.4. Uwagi kocowe ............................................................................................... 270

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

  !          " 


Rozdzia 19.

$    !


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

C++. Szablony. Vademecum profesjonalisty

20.1.6. Kopiowanie posiadaczy ............................................................................ 349


20.1.7. Kopiowanie obiektw posiadaczy pomidzy wywoaniami funkcji ............... 350
20.1.8. Obiekty kurierw..................................................................................... 351
20.2. Zliczanie liczby odwoa .................................................................................. 353
20.2.1. Gdzie umieci licznik?............................................................................ 354
20.2.2. Wspbieny dostp 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. Stao.................................................................................................... 362
20.2.8. Konwersje niejawne................................................................................. 363
20.2.9. Porwnania ............................................................................................. 366
20.3. Uwagi kocowe ............................................................................................... 367

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

4)  

""&
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

W prezentowanym przykadzie lista parametrw zawiera wyraenie  


. Charakterystyczne jest umieszczenie listy parametrw szablonu pomidzy znakami mniejszoci (<) i wikszoci (>) utworzone tak nawiasy nazywamy nawiasami ostrymi.
Sowo kluczowe   wprowadza do listy parametrw tzw. parametr typu (ang. type

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:
 
  

 !"#   
 
$% !"
 % &'#
(

Definicja ta jest znaczeniowo tosama z definicj prezentowan jako pierwsz. Naley


przy tym pamita, e pomimo zastosowania sowa kluczowego  zakres dopuszczalnych typw parametrw szablonu nie jest redukowany do typw definiowanych
przez uytkownika (klas). Wida wic, e stosowanie sowa kluczowego  moe
by mylce ( moe przecie zosta zastpione w wywoaniu rwnie przez typ podstawowy), dlatego w przypadkach wtpliwych zaleca si stosowanie sowa kluczowego
 . W miejsce sowa kluczowego   nie mona natomiast z dobrym skutkiem zastosowa sowa kluczowego   (cho jest on w pewnym zakresie tosamy
ze sowem kluczowym  ).


    

Poniszy program ilustruje sposb wykorzystania zdefiniowanego wczeniej szablonu
funkcji :

  
)%  
)% *
)%+  +
 

,-.#
''%+  /'+''  /''#

Rozdzia 2.  Szablony 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:$ 

Jak wida, szablony s kompilowane dwukrotnie:




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  .

  


Wywoujc szablon funkcji (jak ) z pewnymi argumentami, okrelamy za ich porednictwem parametry szablonu. Jeeli jako parametry 
  przekazane zostan
zmienne typu , kompilator jzyka C++ zaoy, e typem  jest typ . Zauwamy,
e taki sposb wnioskowania o typie parametrw wyklucza stosowanie automatycznej
konwersji typw w miejscu wywoania szablonu funkcji. Kady typ  musi zosta okrelony w sposb jawny. Oto przykad:
 
 
  #
5
 -/#:;7<=>'% *% !
 -- .#789:' 
 *% 
% %*
%%

Rozdzia 2.  Szablony funkcji

27

Bd ten mona wyeliminowa na trzy sposoby:




Przez jawne rzutowanie parametrw do wsplnego typu:


 ?%-- .#:;7<=>



Przez jawne okrelenie typu  w wywoaniu szablonu:


 %-- .#



Przez zdefiniowanie szablonu o dwch rnych parametrach typu.

Szczegowe omwienie kadej z trzech metod znajduje si w kolejnym podrozdziale.

 ! 

Szablony funkcji mona zdefiniowa przy uyciu dwch rodzajw parametrw:


Parametrw szablonu, deklarowanych wewntrz nawiasw ostrych przed nazw


szablonu funkcji:
 
     %



Parametrw wywoania, deklarowanych wewntrz nawiasw zwykych


po nazwie szablonu funkcji:
5  @    
6

Nie istnieje ograniczenie liczby parametrw szablonu. Niemniej jednak w szablonach


funkcji (w przeciwiestwie do szablonw klas) nie mona zdefiniowa domylnych argumentw szablonu 3. Definicja szablonu  taka, aby w wywoaniu przyjmowane
byy argumenty rnych typw, wygldaaby nastpujco:
 
 1
 .
1  1.

 % &'#
(
5
 -- .#:;7<=>
 * *% % %
  A 

Metoda polegajca na dopuszczeniu w wywoaniu parametrw rnych typw wydaje


si skuteczna, ale skuteczno ta jest pozorna. Problem tkwi w typie wartoci zwracanej
przez szablon funkcji. Jeeli warto ta bdzie typu zgodnego z typem jednego z parametrw, argument drugiego typu bdzie musia zosta poddany konwersji do typu pierwszego, niezalenie od intencji programisty. Jzyk C++ nie dysponuje bowiem metodami
pozwalajcymi na wyznaczenie lepszego z dwch typw (cho mona t moliwo
zaimplementowa przy uyciu pewnych sztuczek z szablonami, prezentowanymi w punkcie 15.2.4). Dlatego kolejno przekazywania argumentw wywoania  jako maksimum z wartoci 42 i 66.66 moemy otrzyma warto 66.66 (typu  ) bd 66
3

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<=>
*

Pokazalimy jak dotd przypadki, w ktrych jawnie (w miejscu wywoania) okrelany


by albo kady, albo aden z argumentw szablonu. Moliwe jest rwnie jawne okrelanie jedynie pierwszych kilku argumentw pozostae zostan wydedukowane. W oglnoci konieczne jest okrelenie wszystkich argumentw typw a do ostatniego argumentu, ktrego typ nie moe zosta okrelony niejawnie (przez dedukcj). Jeeli wic
zmienimy kolejno na licie parametrw przykadowego szablonu, bdziemy mogli wywoywa funkcj szablonu, podajc jawnie wycznie typ wartoci zwracanej:
 
 <
 1
 .
<  1.#
5
 %-- .#:;7<=>'
  A %
4

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.

Rozdzia 2.  Szablony funkcji

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

Jeeli na podstawie szablonu mona wygenerowa lepsze dopasowanie, wybierany jest


oczywicie szablon. Przypadek taki mia miejsce w wywoaniach drugim i trzecim:
 / C-. C#
6%  %%$
% *% ! 
 DDDD#
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$!
 
 
F  FF

 % FF&'#
(

Rozdzia 2.  Szablony funkcji

31

 $ %  !@*! G


$H
 F   F F

 % ''  C&'#
(
 

,/#
,-.#
''  # $ %  !  A
%
'' *,++#
'' *,+
+#
''  # $ %  !  A
%'' *
F1,#
F.,#
''  1.# $ %  ! $E$!
 F1,+:I+#
 F.,+J+#
''  1.# $ %  !@*! G
$H
(

We wszystkich implementacjach przecionych argumenty byy przekazywane przez


referencje, bowiem przeciajc szablony funkcji, warto ogranicza zmiany w stosunku
do funkcji zwykych. Zmiany te powinny sprowadza si do zmiany liczby parametrw
lub do jawnego okrelania parametrw szablonu. W przeciwnym przypadku naley przygotowa si na niespodzianki. Przykadowo, po przecieniu szablonu funkcji 
(zakadajcego przekazywanie argumentw przez referencj) dla dwch cigw jzyka
C przekazywanych przez warto, nie mona korzysta z trjargumentowej wersji 
do wskazywania maksimum z trzech cigw jzyka C:

  2 
)%  
)% *
)% *
 $ %  !  A *
% $  0 G
 
 
  

 % &'#
(
 $ %  !@*! G
$H $   A"
 F   F F

 % ''  C&'#
(
 $ %    A *
% $  0 G
 
 
  

32

Cz I  Podstawy

 %     #6@  $ 
 $
   A"
(
 

''  /-.4B#:;7<=>
 F1,+K  +#
 F.,+L+#
 F2,+M%+#
''  1.2#789:
(

Bd pojawia si w miejscu wywoania  dla trzech cigw jzyka C:


%     #

Bd spowodowany jest utworzeniem przez wywoanie "


 nowego, tymczasowego lokalnego wzgldem wywoania, obiektu, ktry nie moe zosta zwrcony na zewntrz przez referencj.
To tylko jeden z moliwych przykadw kodu, ktry bdzie si zachowywa niezgodnie
z oczekiwaniem programisty w wyniku zastosowania regu rozstrzygania przeciania.
Dla przykadu, dla poprawnoci dziaania programu znaczcy moe okaza si fakt widocznoci bd niewidocznoci wszystkich wersji przecionych w miejscu wywoania
funkcji. W rzeczy samej, definiowanie trjargumentowej wersji szablonu  poza
zakresem widocznoci deklaracji zwykej funkcji dwuargumentowej dla typu  moe
spowodowa preferowanie, zamiast funkcji zwykej, szablonu:

  - 
 $ %  !  A *
%
 
 
  

 % &'#
(
 $ %    A *
%
 
 
  

 %     #
$ 
%$$ 
%

% 0%$
$6
$  
6
!E
(
 $ %  !  A
%
  

 % &'#
(

Rozdzia 2.  Szablony funkcji

33

Szersze omwienie tego zagadnienia zamiecilimy w rozdziale 12.; na razie naleaoby


pamita o koniecznoci zdefiniowania wszystkich wersji przecianych funkcji i szablonw przed pierwszym wywoaniem.

%!

 
 Szablony funkcji definiuj rodzin funkcji dla rnych parametrw szablonu.
 Przekazujc w wywoaniu argumenty szablonu, konkretyzujemy szablon funkcji

dla wskazanych typw argumentw.


 Moliwe jest jawne kwalifikowanie parametrw szablonu.
 Moliwe jest przecianie szablonw funkcji.
 Przeciajc szablony funkcji, naley ogranicza zmiany do jawnego okrelania

parametrw szablonu.
 Zawsze warto sprawdzi, czy w miejscu wywoania znane s wszystkie wersje

przecionego szablonu funkcji.

You might also like