Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00357 008404 11063028 na godz. na dobę w sumie
C++. Szablony. Vademecum profesjonalisty - książka
C++. Szablony. Vademecum profesjonalisty - książka
Autor: , Liczba stron: 480
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-175-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).
Choć szablony są częścią definicji języka C++ od ponad dziesięciu lat, wciąż są źródłem nieporozumień, omyłek i kontrowersji. Z drugiej strony, ich popularność jako efektywnych instrumentów tworzenia bardziej eleganckiego, szybszego i 'inteligentniejszego' oprogramowania stale rośnie. W rzeczy samej, szablony osiągnęły rangę kamieni węgielnych dla kilku nowych modeli programowania w języku C++.

Książka 'C++. Szablony. Vademecum profesjonalisty.' zawiera komplet informacji niezbędnych do rozpoczęcia korzystania z szablonów i pełnego wykorzystania ich możliwości, jak również wiedzy pomagającej doświadczonym programistom przekroczyć granicę, za którą programowanie z rzemiosła staje się sztuką. Autorzy założyli, że znasz język C++ i potrafisz programować z wykorzystaniem komponentów biblioteki standardowej. Prezentowane w książce przykłady znakomicie ilustrują abstrakcyjne pojęcia i demonstrują najlepsze praktyki programistyczne.

Poznasz:

Niektóre z technik przestawionych w 'C++. Szablony. Vademecum profesjonalisty' nie doczekały się jeszcze opracowania w innych publikacjach. Jeśli w programowaniu w C++ chcesz osiągnąć najwyższy poziom, nie obędziesz się bez tej książki.
Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl C++. Szablony. Vademecum profesjonalisty Autorzy: David Vandevoorde, Nicolai M. Josuttis T³umaczenie: Przemys³aw Szeremiota ISBN: 83-7361-175-4 Tytu³ orygina³u: C++ Templates The Complete Guide Format: B5, stron: 474 Choæ szablony s¹ czêġci¹ definicji jêzyka C++ od ponad dziesiêciu lat, wci¹¿ s¹ ĥród³em nieporozumieñ, omy³ek i kontrowersji. Z drugiej strony, ich popularnoġæ jako efektywnych instrumentów tworzenia bardziej eleganckiego, szybszego i „inteligentniejszego” oprogramowania stale roġnie. W rzeczy samej, szablony osi¹gnê³y rangê kamieni wêgielnych dla kilku nowych modeli programowania w jêzyku C++. Ksi¹¿ka C++. Szablony. Vademecum profesjonalisty. zawiera komplet informacji niezbêdnych do rozpoczêcia korzystania z szablonów i pe³nego wykorzystania ich mo¿liwoġci, jak równie¿ wiedzy pomagaj¹cej doġwiadczonym programistom przekroczyæ granicê, za któr¹ programowanie z rzemios³a staje siê sztuk¹. Autorzy za³o¿yli, ¿e znasz jêzyk C++ i potrafisz programowaæ z wykorzystaniem komponentów biblioteki standardowej. Prezentowane w ksi¹¿ce przyk³ady znakomicie ilustruj¹ abstrakcyjne pojêcia i demonstruj¹ najlepsze praktyki programistyczne. Poznasz: • sposoby unikania pu³apek towarzysz¹cych stosowaniu szablonów, • idiomy i techniki zwi¹zane z szablonami -- od technik najprostszych do takich, które poza t¹ ksi¹¿k¹ nie zosta³y jeszcze nigdzie dokumentowane, • sposoby wielokrotnego wykorzystywania tego samego kodu ĥród³owego bez zmniejszania jego wydajnoġci i bezpieczeñstwa, • sposoby zwiêkszania efektywnoġci programów w jêzyku C++, • sposoby tworzenia oprogramowania bardziej elastycznego i ³atwiejszego w utrzymaniu. Niektóre z technik przestawionych w „C++. Szablony. Vademecum profesjonalisty” nie doczeka³y siê jeszcze opracowania w innych publikacjach. Jeġli w programowaniu w C++ chcesz osi¹gn¹æ najwy¿szy poziom, nie obêdziesz siê bez tej ksi¹¿ki. 5RKUVTGħEK 2TGFOQYC   Rozdział 1. 1MUKæľ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[F Rozdział 2. Rozdział 3. Rozdział 4. Rozdział 5. 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 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 2QCV[RQYGRCTCOGVT[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 -KNMCUVWEGM  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 Rozdział 6. Rozdział 7. 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 2TCMV[EPGCUVQUQYCPKGUCDNQPÎ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 2QFUVCYQYGRQLúEKCYKæCPGUCDNQPCOK   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 F Rozdział 8. 2QFUVCY[ōFTWIKGRT[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[YUCDNQPCEJ   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. GFWMELCCTIWOGPVÎYUCDNQPW  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. 5RGELCNKCELGKRTGEKæľCPKG   12.1. Kiedy kod uogólniony nie jest odpowiedni?...................................................ż..... 177 12.1.1. Przezroczystość dopasowania ...................................................ż................ 178 12.1.2. Przezroczystość semantyczna ...................................................ż................ 179 12.2. Przeciążanie szablonów funkcji ...................................................ż...................... 180 12.2.1. Sygnatury ...................................................ż............................................ 181 12.2.2. Porządkowanie częściowe przeciążonych szablonów funkcji ....................... 183 8 C++. Szablony. Vademecum profesjonalisty 12.2.3. Formalne reguły porządkowania...................................................ż............. 184 12.2.4. Szablony funkcji a funkcje zwykłe ...................................................ż......... 186 12.3. Specjalizacja jawna ...................................................ż....................................... 187 12.3.1. Pełna specjalizacja szablonu klasy ...................................................ż.......... 187 12.3.2. Pełna specjalizacja szablonu funkcji ...................................................ż....... 191 12.3.3. Pełna specjalizacja składowej..................................................ż.................. 193 12.4. Częściowa specjalizacja szablonu klasy...................................................ż........... 195 12.5. Uwagi końcowe ...................................................ż............................................ 198 Rozdział 13. -KGTWPMKTQYQLW   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[YRTQLGMVQYCPKW   Rozdział 14. 5KđCRQNKOQTHKOWUCDNQPÎ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[EGEJKY[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[KFKGFKEGPKG   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 CCYCPUQYCPGCUVQUQYCPKCUCDNQPÎY  Rozdział 19. -NCU[HKMCELCV[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. +PVGNKIGPVPGYUMCļ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 10 C++. Szablony. Vademecum profesjonalisty 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[LPGKHWPMELGYTQVPG   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 Dodatek B 4GIWđCRQLGF[PEGLFGHKPKELK   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 4QUVT[ICPKGRTGEKæľ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.  GHKPKQYCPKGUCDNQPW Poniższy kod stanowi deklarację szablonu funkcji zwracającej większą z dwu przekaza- nych do niej wartości: RQFUVCY[OCZJRR VGORNCVGV[RGPCOG6 KPNKPG6EQPUVOCZ 6EQPUVC6EQPUVD ] LGľGNKCDYTÎèDYRTGEKYP[ORT[RCFMWYTÎèC[ TGVWTPCD!DC _ 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: VGORNCVGNKUVCRCTCOGVTÎ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: VGORNCVGENCUU6 KPNKPG6EQPUVOCZ 6EQPUVC6EQPUVD ] LGľGNKCDYTÎèDYRTGEKYP[ORT[RCFMWYTÎèC[ TGVWTPCD!DC _ 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[UVCPKGUCDNQPW Poniższy program ilustruje sposób wykorzystania zdefiniowanego wcześniej szablonu funkcji OCZ : RQFUVCY[OCZERR KPENWFGKQUVTGCO KPENWFGUVTKPI KPENWFGOCZJRR KPVOCKP ] KPVK UVFEQWVOCZ K OCZ K UVFGPFN[ Rozdział 2.  Szablony funkcji 25 FQWDNGH FQWDNGHŌ UVFEQWVOCZ HH OCZ HH UVFGPFN UVFUVTKPIUOCVGOCV[MC UVFUVTKPIUOCVGOC UVFEQWVOCZ UU OCZ UU UVFGPF[N _ 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 HH  OCZ UU 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 : KPVK ŗ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: KPNKPGKPVEQPUVOCZ KPVEQPUVCKPVEQPUVD ] LGľGNKCDYTÎèDYRTGEKYP[ORT[RCFMWYTÎèC[ TGVWTPCD!DC _ 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). e 1 2 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 . 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. 26 Część I  Podstawy 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: EQPUVFQWDNGOCZ FQWDNGEQPUVFQWDNGEQPUV  EQPUVUVFUVTKPIOCZ UVFUVTKPIEQPUVUVFUVTKPIEQPU[V  Próba konkretyzacji szablonu dla typu, który nie obsługuje wszystkich operacji wyko- rzystywanych w szablonie, sprowokuje błąd kompilacji. Przykład: UVFEQORNGZHNQCV EEV[REQORNGZPKGQDUđWIWLG[QRGTCVQTC ŗ OCZ EE $Đä 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.  GFWMELCV[RWCTIWOGPVÎ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: VGORNCVGV[RGPCOG6 KPNKPG6EQPUVOCZ 6EQPUVC6EQPUVD  ŗ OCZ   1$4 6VQKPVFNCQDWCTIWOGPVÎY OCZ  $Đä RKGTYU[CTIWOGPVLGUVV[RWKPVF[TWIKV[RWFQWDNG Rozdział 2.  Szablony funkcji 27 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: VGORNCVGV[RGPCOG6 6LGUVRCTCO[GVTGOUCDNQPW  Parametrów wywołania, deklarowanych wewnątrz nawiasów zwykłych po nazwie szablonu funkcji: ŗOCZ 6EQPUVC6EQPUVD CKDUæRCTCO[GVTCOKY[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: VGORNCVGV[RGPCOG6V[RGPCOG6 KPNKPG6OCZ 6EQPUVC6EQPUVD ] TGVWTPCD!DC _ ŗ OCZ   1$4 CNGV[RRKGTYUGIQCTIWOGPVWFGVGTOKPWLGV[RYCTVQħEKYTCECPGL 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 e 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). 28 Część I  Podstawy (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 6EQPUV. 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: VGORNCVGV[RGPCOG6 KPNKPG6EQPUVOCZ 6EQPUVC6EQPUVD  ŗ OCZFQWDNG  MQPMTGV[CELCLCYP[CV[RW6FQV[RWFQWDNG 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: VGORNCVGV[RGPCOG6V[RGPCOG6V[RGPCOG46 KPNKPG46OCZ 6EQPUVC6EQPUVD  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: VGORNCVGV[RGPCOG6V[RGPCOG6V[RGPCOG46 KPNKPG46OCZ 6EQPUVC6EQPUVD  ŗ OCZKPVFQWDNGFQWDNG   1$4 CNGPKGY[IQFP[KG 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: VGORNCVGV[RGPCOG46V[RGPCOG6V[RGPCOG6 KPNKPG46OCZ 6EQPUVC6EQPUVD  ŗ OCZFQWDNG   1$4 V[RYCTVQħEKYTCECPGLV[QFQWDNG e 4 5 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ć. 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. Rozdział 2.  Szablony funkcji 29 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æľCPKGUCDNQPÎYHWPMELK 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 OCMUKOWOFYÎEJYCTVQħEKV[RWKPV KPNKPGKPVEQPUVOCZ KPVEQPUVCKPVEQPUVD ] TGVWTPCD!DC _ OCMUKOWOFYÎEJYCTVQħEKFQYQNPGIQV[RW VGORNCVGV[RGPCOG6 KPNKPG6EQPUVOCZ 6EQPUVC6EQPUVD ] TGVWTPCD!DC _ OCMUKOWOVTGEJYCTVQħEKFQYQNPGIQV[RW VGORNCVGV[RGPCOG6 KPNKPG6EQPUVOCZ 6EQPUVC6EQPUVD6EQPU[VE ] TGVWTPOCZ OCZ CD E  _ KPVOCKP ] OCZ  Y[YQđCPKGUCDNQPWRTGMCCPKGOVTGEJCTIWOGPVÎY OCZ  Y[YQđCPKGUCDNQPWOCZFQWDNG  FGFWMELCV[RWCTIWOGPVÎY 30 Część I  Podstawy OCZ C  D Y[YQđCPKGUCDNQPWOCZFQWDNG  FGFWMELCV[RWCTIWOGPVÎY OCZ  Y[YQđCPKGHWPMELKY[MđGLFNCFYÎEJCTIWOGPVÎYKPV OCZ  Y[YQđCPKGUCDNQPWOCZKPV  FGFWMELCV[RWCTIWOGPVÎY OCZFQWDNG  Y[YQđCPKGUCDNQPWOCZFQWDNG  DGFGFWMELKV[RW OCZ C  Y[YQđCPKGHWPMELKY[MđGLFNCFYÎEJCTIWOGPVÎYKPV _ 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  QDCCTIWOGPV[QFRQYKCFCLæHWPMELKY[[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  Y[YQđCPKGUCDNQPWOCZFQWDNG  FG[FWMELCV[RWCTIWOGPVÎY OCZ C  D Y[YQđCPKGUCDNQPWOCZEJCT  FGFW[MELCV[RWCTIWOGPVÎY 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đCPKGUCDNQPWOCZKPV  FGF[WMELCV[RWCTIWOGPVÎY 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[NMQY[MđCHWPMELCFQRWUECTÎľPGV[[R[CTIWOGPVÎYY[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 KPENWFGKQUVTGCO KPENWFGEUVTKPI KPENWFGUVTKPI OCMUKOWOFYÎEJYCTVQħEKFQYQNPGIQV[RW VGORNCVGV[RGPCOG6 KPNKPG6EQPUVOCZ 6EQUVC6EQPUVD ] TGVWTPCD!DC _ OCMUKOWOFYÎEJYUMCļPKMÎY VGORNCVGV[RGPCOG6 KPNKPG6 EQPUVOCZ 6 EQUVC6 EQPUVD ] TGVWTP C D!DC _ Rozdział 2.  Szablony funkcji 31 OCMUKOWOFYÎEJEKæIÎYLú[MC KPNKPGEJCTEQPUV EQPUVOCZ EJCTEQPUV EQPUVCE[JCTEQPUV EQPUVD ] TGVWTPUVFUVTEOR CD !DC _ KPVOCKP ] KPVC KPVD OCZ CD OCMUKOWOFYÎEJYCTVQħEKV[RWK[PV UVFUVTKPIUJGL UVFUVTKPIVV[ OCZ UV OCMUKOWOFYÎEJYCTVQħEKV[RWU[VFUVTKPI KPV RD KPV RC OCZ RR OCMUKOWOFYÎEJYUMCļPKMÎY EJCTEQPUV U CXKF EJCTEQPUV U0KEQ OCZ UU OCMUKOWOFYÎEJEKæIÎYLú[MC _ We wszystkich implementacjach przeciążonych argumenty były przekazywane przez referencje, bowiem przeciążając szablony funkcji, warto ograniczać zmiany w stosunku do funkcji zwykłych. Zmiany te powinny sprowadzać się do zmiany liczby parametrów lub do jawnego określania parametrów szablonu. W przeciwnym przypadku należy przy- gotować się na niespodzianki. Przykładowo, po przeciążeniu szablonu funkcji OCZ (zakładającego przekazywanie argumentów przez referencję) dla dwóch ciągów języka C przekazywanych przez wartość, nie można korzystać z trójargumentowej wersji OCZ do wskazywania maksimum z trzech ciągów języka C: RQFUVCY[OCZCERR KPENWFGKQUVTGCO KPENWFGEUVTKPI KPENWFGUVTKPI OCMUKOWOFYÎEJYCTVQħEKFQYQNPGIQV[RW RTGMCCPKG[RTGTGHGTGPELú VGORNCVGV[RGPCOG6 KPNKPG6EQPUVOCZ 6EQUVC6EQPUVD ] TGVWTPCD!DC _ OCMUKOWOFYÎEJEKæIÎYLú[MC  RTGMCCPKGRTGYCTVQ[ħè KPNKPGEJCTEQPUV OCZ EJCTEQPUV CEJCTEQPUV D ] TGVWTPUVFUVTEOR CD !DC _ OCMUKOWOVTGEJYCTVQħEKFQYQNPGIQV[RW RTGMCCPKG[RTGTGHGTGPELú VGORNCVGV[RGPCOG6 KPNKPG6EQPUVOCZ 6EQPUVC6EQPUVD6EQPU[VE 32 Część I  Podstawy ] TGVWTPOCZ OCZ CD E DđæFLGľGNKOCZ C[D MQT[UVCRTGMCCPKC RTGYCTVQħè _ KPVOCKP ] OCZ   1$4 EQPUVEJCT U(TGFGTKE EQPUVEJCT U#PKEC EQPUVEJCT U.WECU OCZ UUU $Đä _ Błąd pojawia się w miejscu wywołania OCZ dla trzech ciągów języka C: TGVWTPOCZ OCZ CD E  Błąd spowodowany jest utworzeniem przez wywołanie OCZ C D nowego, tymczaso- wego lokalnego względem wywołania, obiektu, który nie może zostać zwrócony na ze- wnątrz przez referencję. To tylko jeden z możliwych przykładów kodu, który będzie się zachowywał niezgodnie z oczekiwaniem programisty w wyniku zastosowania reguł rozstrzygania przeciążania. Dla przykładu, dla poprawności działania programu znaczący może okazać się fakt wi- doczności bądź niewidoczności wszystkich wersji przeciążonych w miejscu wywołania funkcji. W rzeczy samej, definiowanie trójargumentowej wersji szablonu OCZ poza zakresem widoczności deklaracji zwykłej funkcji dwuargumentowej dla typu KPV może spowodować preferowanie, zamiast funkcji zwykłej, szablonu: RQFUVCY[OCZERR OCMUKOWOFYÎEJYCTVQħEKFQYQNPGIQV[RW VGORNCVGV[RGPCOG6 KPNKPG6EQPUVOCZ 6EQPUVC6EQPUVD ] TGVWTPCD!DC _ OCMUKOWOVTGEJYCTVQħEKFQYQNPGIQV[RW VGORNCVGV[RGPCOG6 KPNKPG6EQPUVOCZ 6EQPUVC6EQPUVD6EQPU[VE ] TGVWTPOCZ OCZ CD E Y[MQT[UVCPCVWQUV[CPKGMQPMTGV[CELCUCDNQPW FNCV[RWKPVR[QPKGYCľHWPMELCY[MđC CFGMNCTQYCPC QUVCđCD[VRÎļP[Q _ OCMUKOWOFYÎEJYCTVQħEKV[RWKPV KPNKPGKPVEQPUVOCZ KPVEQPUVCKPVEQPUVD ] TGVWTPCD!DC _ Rozdział 2.  Szablony funkcji 33 Szersze omówienie tego zagadnienia zamieściliśmy w rozdziale 12.; na razie należałoby pamiętać o konieczności zdefiniowania wszystkich wersji przeciążanych funkcji i sza- blonów przed pierwszym wywołaniem. 2QFUWOQYCPKG  Szablony funkcji definiują rodzinę funkcji dla różnych parametrów szablonu.  Przekazując w wywołaniu argumenty szablonu, konkretyzujemy szablon funkcji dla wskazanych typów argumentów.  Możliwe jest jawne kwalifikowanie parametrów szablonu.  Możliwe jest przeciążanie szablonów funkcji.  Przeciążając szablony funkcji, należy ograniczać zmiany do jawnego określania parametrów szablonu.  Zawsze warto sprawdzić, czy w miejscu wywołania znane są wszystkie wersje przeciążonego szablonu funkcji.
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C++. Szablony. Vademecum profesjonalisty
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: