...

jezyk-c++.-metaprogramowanie-za-pomoca-szablonow scan, ebooki

[ Pobierz całość w formacie PDF ]
IDZ DO
PRZYK£ADOW
Jêzyk C++.
Metaprogramowanie
za pomoc¹ szablonów
SPIS TRECI
KATALOG KSI¥¯EK
KATALOG ONLINE
Autorzy: David Abrahams, Aleksey Gurtovoy
T³umaczenie: Rafa³ Joñca
ISBN: 83-7361-935-6
Tytu³ orygina³u
Format: B5, stron: 336
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
Metaprogramowanie to jedna z nowoci, które pojawi³y siê ostatnio w wiecie jêzyka
C++. Metaprogram to program bêd¹cy w stanie modyfikowaæ lub generowaæ kod
innego programu. Wykorzystanie zasad metaprogramowania pozwala na przyk³ad
na dynamiczn¹ modyfikacjê programu podczas jego kompilacji. Pierwszym jêzykiem
pozwalaj¹cym na korzystanie z mo¿liwoci metaprogramowania jest C++ bibliotek¹ STL.
„C++. Metaprogramowanie za pomoc¹ szablonów” to ksi¹¿ka przeznaczona dla tych
programistów, którzy korzystaj¹ ju¿ z biblioteki STL i chc¹ zastosowaæ j¹ do tworzenia
metaprogramów. Opisano w niej zasady metaprogramowania, typy mo¿liwe do
wykorzystania w szablonach przeznaczonych do implementacji funkcji zwi¹zanych
z metaprogramowaniem oraz sposoby tworzenia szablonów modyfikuj¹cych programy
podczas kompilacji.
• Typy i metafunkcje
• Operacje, sekwencje i iteratory
• Algorytmy biblioteki MPL i tworzenie w³asnych algorytmów
• Usuwanie b³êdów w szablonach
• Modyfikowanie programu w czasie kompilacji
• Jêzyk DSEL
Metaprogramowanie to nowoæ. Poznaj je ju¿ teraz, aby byæ przygotowanym na dzieñ,
w którym stanie siê standardem.
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWOCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
 Spis treci
Przedmowa .......................................................................................7
Podzikowania ..................................................................................9
Struktura ksiki ............................................................................11
Rozdział 1. Wprowadzenie ................................................................................13
1.1. Zaczynamy .............................................................................................................13
1.2. Czym jest metaprogram? .......................................................................................14
1.3. Metaprogramowanie w jzyku macierzystym ........................................................15
1.4. Metaprogramowanie w jzyku C++ .......................................................................15
1.5. Dlaczego metaprogramowanie? .............................................................................18
1.6. Kiedy stosowa& metaprogramowanie? ...................................................................20
1.7. Dlaczego biblioteka metaprogramowania? ............................................................20
Rozdział 2. Cechy typu i manipulowanie nim ......................................................23
2.1. Powi+zanie typów ..................................................................................................23
2.2. Metafunkcje ...........................................................................................................26
2.3. Metafunkcje numeryczne .......................................................................................29
2.4. Dokonywanie wyborów na etapie kompilacji ........................................................30
2.5. Krótka podró/ po bibliotece Boost Type Traits .....................................................34
2.6. Metafunkcje bezargumentowe ...............................................................................39
2.7. Definicja metafunkcji ............................................................................................40
2.8. Historia ..................................................................................................................40
2.9. Szczegóły ...............................................................................................................41
2.10. 5wiczenia ..............................................................................................................44
Rozdział 3. Dokładniejsze omówienie metafunkcji ..............................................47
3.1. Analiza wymiarowa ...............................................................................................47
3.2. Metafunkcje wy/szych rzdów ..............................................................................56
3.3. Obsługa symboli zastpczych ................................................................................58
3.4. Wicej mo/liwo:ci lambdy ....................................................................................60
3.5. Szczegóły implementacji lambda ...........................................................................61
3.6. Szczegóły ...............................................................................................................64
3.7. 5wiczenia ..............................................................................................................66
Rozdział 4. Operacje i otoczki typów całkowitych ..............................................69
4.1. Operacje i otoczki typu logicznego ........................................................................69
4.2. Operacje i otoczki liczb całkowitych .....................................................................76
4.3. 5wiczenia ..............................................................................................................80
 4
Spis treci
Rozdział 5. Sekwencje i iteratory ......................................................................83
5.1. Pojcia ...................................................................................................................83
5.2. Sekwencje i algorytmy ...........................................................................................84
5.3. Iteratory .................................................................................................................85
5.4. Pojcia zwi+zane z iteratorem ................................................................................85
5.5. Pojcia sekwencji ...................................................................................................89
5.6. Równo:& sekwencji ...............................................................................................94
5.7. Wewntrzne operacje sekwencji ............................................................................94
5.8. Klasy sekwencji .....................................................................................................95
5.9. Otoczki sekwencji liczb całkowitych .....................................................................99
5.10. Wyprowadzanie sekwencji ..................................................................................100
5.11. Pisanie własnych sekwencji .................................................................................101
5.12. Szczegóły ............................................................................................................110
5.13. 5wiczenia ............................................................................................................111
Rozdział 6. Algorytmy .....................................................................................115
6.1. Algorytmy, idiomy, wielokrotne u/ycie i abstrakcja ...........................................115
6.2. Algorytmy biblioteki MPL ..................................................................................117
6.3. Insertery ...............................................................................................................118
6.4. Podstawowe algorytmy sekwencji .......................................................................121
6.5. Algorytmy zapyta? ..............................................................................................123
6.6. Algorytmy budowania sekwencji .........................................................................123
6.7. Pisanie własnych algorytmów ..............................................................................126
6.8. Szczegóły .............................................................................................................127
6.9. 5wiczenia ............................................................................................................128
Rozdział 7. Widoki i adaptery iteratorów .........................................................131
7.1. Kilka przykładów .................................................................................................131
7.2. Pojcie widoku ....................................................................................................137
7.3. Adaptery iteratora ................................................................................................137
7.4. Tworzenie własnego widoku ...............................................................................138
7.5. Historia ................................................................................................................140
7.6. 5wiczenia ............................................................................................................140
Rozdział 8. Diagnostyka .................................................................................143
8.1. Powie:& o poprawianiu błdów ...........................................................................143
8.2. Korzystanie z narzdzi do analizy wyników diagnostyki ....................................152
8.3. Zamierzone generowanie komunikatów diagnostycznych ...................................156
8.4. Historia ................................................................................................................167
8.5. Szczegóły .............................................................................................................167
8.6. 5wiczenia ............................................................................................................168
Rozdział 9. Przekraczanie granicy midzy czasem kompilacji
i wykonywania programu ...............................................................171
9.1. Algorytm for_each ...............................................................................................171
9.2. Wybór implementacji ..........................................................................................174
9.3. Generatory obiektów ............................................................................................178
9.4. Wybór struktury ...................................................................................................180
9.5. Zło/enie klas ........................................................................................................184
9.6. WskaBniki na funkcje (składowe) jako argumenty szablonów ............................187
9.7. Wymazywanie typu .............................................................................................189
9.8. Wzorzec zadziwiaj+co powracaj+cego szablonu ..................................................195
9.9. Jawne zarz+dzanie zbiorem przeci+/e? ................................................................200
9.10. Sztuczka z sizeof .................................................................................................202
9.11. Podsumowanie .....................................................................................................203
9.12. 5wiczenia ............................................................................................................203
Spis treci
5
Rozdział 10. Jzyk osadzony zaleny od dziedziny ..............................................205
10.1. Mały jzyk… .......................................................................................................205
10.2. …przechodzi dług+ drog ....................................................................................208
10.3. Jzyki DSL — podej:cie odwrotne .....................................................................215
10.4. C++ jako jzyk gospodarza .................................................................................218
10.5. Blitz++ i szablony wyra/e? .................................................................................220
10.6. Jzyki DSEL ogólnego stosowania ......................................................................225
10.7. Biblioteka Boost Spirit ........................................................................................234
10.8. Podsumowanie .....................................................................................................240
10.9. 5wiczenia ............................................................................................................241
Rozdział 11. Przykład projektowania jzyka DSEL ..............................................243
11.1. Automaty sko?czone ...........................................................................................243
11.2. Cele projektu szkieletu ........................................................................................246
11.3. Podstawy interfejsu szkieletu ..............................................................................247
11.4. Wybór jzyka DSL ..............................................................................................248
11.5. Implementacja .....................................................................................................254
11.6. Analiza ................................................................................................................259
11.7. Kierunek rozwoju jzyka .....................................................................................261
11.8. 5wiczenia ............................................................................................................261
Dodatek A Wprowadzenie do metaprogramowania za pomoc preprocesora .....265
A.1. Motywacja ...........................................................................................................265
A.2. Podstawowe abstrakcje preprocesora ...................................................................267
A.3. Struktura biblioteki preprocesora .........................................................................269
A.4. Abstrakcje biblioteki preprocesora .......................................................................269
A.5. 5wiczenie .............................................................................................................286
Dodatek B Słowa kluczowe typename i template ............................................287
B.1. Zagadnienia ..........................................................................................................288
B.2. Reguły ..................................................................................................................291
Dodatek C Wydajno45 kompilacji ...................................................................299
C.1. Model obliczeniowy .............................................................................................299
C.2. Zarz+dzanie czasem kompilacji ............................................................................302
C.3. Testy .....................................................................................................................302
Dodatek D Podsumowanie przeno4no4ci biblioteki MPL .................................315
Bibliografia ...................................................................................317
Skorowidz .....................................................................................321
Rozdział 1.
Wprowadzenie
Warto potraktowa ten rozdział jako rozgrzewk przed pozostał czci ksiki.
Przewiczymy tutaj najwaniejsze narzdzia, a take zapoznamy si z podstawowymi
pojciami i terminologi. Pod koniec rozdziału kady powinien ju mniej wicej wie-
dzie, o czym jest niniejsza ksika, i by głodnym kolejnych informacji.
1.1. Zaczynamy
Jedn z przyjemnych kwestii zwizanych z metaprogramowaniem szablonami jest
współdzielenie pewnej właciwoci z tradycyjnymi, starymi systemami. Po napisaniu
metaprogramu mona go uywa bez zastanawiania si nad jego szczegółami —
oczywicie o ile wszystko działa prawidłowo.
Aby uwiadomi kademu, e przedstawiona kwestia to nie tylko wymylna teoria,
prezentujemy prosty program C++, który po prostu uywa elementu zaimplementowa-
nego jako metaprogram szablonu.
!
!
"
Nawet jeli jest si dobrym w arytmetyce binarnej i od razu mona odgadn wynik
działania programu bez jego uruchamiania, warto zada sobie ten trud i go skompilo-
wa oraz uruchomi. Poza upewnieniem si w kwestii samej koncepcji, jest to dobry
test sprawdzajcy, czy wykorzystywany kompilator potrafi obsłuy kod przedsta-
wiany w ksice. Wynikiem działania programu powinno by wywietlenie na stan-
dardowym wyjciu wartoci dziesitnej liczby binarnej 101010:
#$
   [ Pobierz całość w formacie PDF ]