C++ Metaprogramowanie za pomoca szablonow.pdf

IDZ DO

PRZYK£ADOW Y ROZDZIA£

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 : C++ Template Metaprogramming:

Concepts, Tools, and Techniques from Boost and Beyond

Format: B5, stron: 336

ZAMÓW DRUKOWANY KATALOG

TWÓJ KOSZYK

DODAJ DO KOSZYKA

CENNIK I INFORMACJE

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.

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

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

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:

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: