nowoczesne-projektowanie-w-c++.-uogolnione-implementacje-wzorcow-projektowych cała książka.pdf

(11412 KB) Pobierz
888449913.008.png
Spis treci
Przedmowy .....................................................................................................9
Wstp ...........................................................................................................13
Podzikowania .............................................................................................19
Techniki ..............................................................................................................21
1 Klasy konfigurowane wytycznymi ..............................................................23
1.1. Projektowanie oprogramowania — klska urodzaju? ...................................................................23
1.2. Poraka interfejsu „wszechstronnego” .........................................................................................24
1.3. Ratunek w wielodziedziczeniu? ....................................................................................................26
1.4. Zalety szablonów ..........................................................................................................................26
1.5. Wytyczne i klasy wytycznych ......................................................................................................28
1.6. Wytyczne rozszerzone ..................................................................................................................32
1.7. Destruktory klas wytycznych .......................................................................................................33
1.8. Elementy opcjonalne w konkretyzacji czciowej ........................................................................34
1.9. czenie klas wytycznych ............................................................................................................35
1.10. Klasy wytycznych a konfigurowanie struktury ...........................................................................37
1.11. Wytyczne zgodne i niezgodne ....................................................................................................38
1.12. Dekompozycja klas na wytyczne ................................................................................................40
1.13. Podsumowanie ............................................................................................................................42
2.
Techniki .......................................................................................................43
2.1. Asercje statyczne ..........................................................................................................................44
2.2. Czciowa specjalizacja szablonu ................................................................................................46
2.3. Klasy lokalne ................................................................................................................................48
2.4. Mapowanie staych na typy ..........................................................................................................49
888449913.009.png 888449913.010.png 888449913.011.png
 
4
SPIS TRECI
2.5. Odwzorowanie typu na typ ...........................................................................................................52
2.6. Wybór typu ...................................................................................................................................53
2.7. Statyczne wykrywanie dziedziczenia i moliwoci konwersji ......................................................55
2.8. TypeInfo .......................................................................................................................................58
2.9. NullType i EmptyType .................................................................................................................60
2.10. Cechy typów ...............................................................................................................................61
2.11. Podsumowanie ............................................................................................................................68
3.
Listy typów ..................................................................................................71
3.1. Listy typów — do czego? .............................................................................................................71
3.2. Definiowanie list typów ................................................................................................................73
3.3. Liniowe tworzenie list typów .......................................................................................................75
3.4. Obliczanie dugoci listy ..............................................................................................................76
3.5. Przygrywka ...................................................................................................................................77
3.6. Dostp swobodny (indeksowany) .................................................................................................77
3.7. Przeszukiwanie list typów ............................................................................................................79
3.8. Dopisywanie do listy typów .........................................................................................................80
3.9. Usuwanie typu z listy ...................................................................................................................81
3.10. Usuwanie duplikatów .................................................................................................................82
3.11. Zastpowanie elementu na licie typów .....................................................................................83
3.12. Czciowe porzdkowanie listy typów .......................................................................................84
3.13. Generowanie klas z list typów ....................................................................................................87
3.14. Podsumowanie ............................................................................................................................97
3.15. Listy typów — na skróty ............................................................................................................97
4.
Przydzia pamici dla niewielkich obiektów .............................................101
4.1. Domylny alokator pamici dynamicznej ...................................................................................102
4.2. Zasada dziaania alokatora pamici ............................................................................................102
4.3. Alokator maych obiektów .........................................................................................................104
4.4. Chunk .........................................................................................................................................105
4.5. Alokator przydziaów o staym rozmiarze ..................................................................................108
4.6. Klasa SmallObjAlocator .............................................................................................................112
4.7. 3 x Tak ........................................................................................................................................113
4.8. Proste, skomplikowane, a potem znów proste ............................................................................116
4.9. Konfigurowanie alokatora ..........................................................................................................117
4.10. Podsumowanie ..........................................................................................................................118
4.11. Alokator maych obiektów — na skróty ...................................................................................119
I Komponenty .....................................................................................................121
5 Uogólnione obiekty funkcyjne ...................................................................123
5.1. Wzorzec Command ....................................................................................................................124
5.2. Wzorzec Command w praktyce ..................................................................................................126
888449913.001.png 888449913.002.png 888449913.003.png
 
5
SPIS TRECI
5.3. Byty funkcyjne w C++ ...............................................................................................................127
5.4. Szkielet szablonu klasy Functor .................................................................................................129
5.5. Delegowanie wywoania Functor::operator() .............................................................................133
5.6. Funktory .....................................................................................................................................135
5.7. Raz a dobrze ...............................................................................................................................137
5.8. Konwersje typów argumentów i wartoci zwracanej ..................................................................139
5.9. Wskaniki do metod ...................................................................................................................140
5.10. Wizanie argumentów wywoania ............................................................................................144
5.11. dania skomasowane ..............................................................................................................147
5.12. Z ycia wzite (1) — duy koszt delegacji funkcji ...................................................................147
5.13. Z ycia wzite (2) — alokacje na stercie ..................................................................................149
5.14. Szablon Functor w implementacji cofnij-powtórz ....................................................................150
5.15. Podsumowanie ..........................................................................................................................151
5.16. Functor — na skróty .................................................................................................................152
6.
Singletony ..................................................................................................155
6.1. Statyczne dane i statyczne funkcje nie czyni singletona ...........................................................156
6.2. Podstawowe idiomy C++ dla singletonów .................................................................................157
6.3. Wymuszanie unikalnoci ............................................................................................................158
6.4. Usuwanie singletona ...................................................................................................................159
6.5. Problem martwych referencji .....................................................................................................162
6.6. Problem martwych referencji (1) — singleton à la feniks ..........................................................164
6.7. Problem martwych referencji (2) — sterowanie ywotnoci ....................................................167
6.8. Implementowanie singletonów z ywotnoci ...........................................................................169
6.9. ycie w wielu wtkach ...............................................................................................................173
6.10. Podsumowanie dowiadcze ....................................................................................................176
6.11. Stosowanie szablonu SingletonHolder .....................................................................................181
6.12. Podsumowanie ..........................................................................................................................183
6.13. Szablon klasy SingletonHolder — na skróty ............................................................................183
7.
Inteligentne wskaniki ...............................................................................185
7.1. Elementarz inteligentnych wskaników .....................................................................................186
7.2. Oferta ..........................................................................................................................................187
7.3. Przydzia obiektów inteligentnych wskaników .........................................................................188
7.4. Metody inteligentnego wskanika ..............................................................................................190
7.5. Strategie zarzdzania posiadaniem .............................................................................................191
7.6. Operator pobrania adresu ............................................................................................................199
7.7. Niejawna konwersja na typ goego wskanika ...........................................................................200
7.8. Równo i róno ......................................................................................................................202
7.9. Porównania porzdkujce ...........................................................................................................207
7.10. Kontrola i raportowanie o bdach ............................................................................................210
7.11. Wskaniki niemodyfikowalne i wskaniki do wartoci niemodyfikowalnych .........................211
7.12. Tablice ......................................................................................................................................212
7.13. Inteligentne wskaniki a wielowtkowo ................................................................................213
7.14. Podsumowanie dowiadcze ....................................................................................................217
7.15. Podsumowanie ..........................................................................................................................223
7.16. Wskaniki SmartPtr — na skróty .............................................................................................224
888449913.004.png
 
6
SPIS TRECI
8 Wytwórnie obiektów ..................................................................................225
8.1. Przydatno wytwórni obiektów .................................................................................................226
8.2. Wytwórnie obiektów w C++ — klasy a obiekty .........................................................................228
8.3. Implementowanie wytwórni obiektów .......................................................................................229
8.4. Identyfikatory typu .....................................................................................................................234
8.5. Uogólnienie ................................................................................................................................235
8.6. Sprostowania ..............................................................................................................................239
8.7. Wytwórnie klonów .....................................................................................................................240
8.8. Stosowanie wytwórni obiektów z innymi komponentami uogólnionymi ...................................243
8.9. Podsumowanie ............................................................................................................................244
8.10. Szablon klasy Factory — na skróty ..........................................................................................244
8.11. Szablon klasy CloneFactory — na skróty .................................................................................245
9 Wzorzec Abstract Factory ..........................................................................247
9.1. Rola wytwórni abstrakcyjnej w architekturze .............................................................................247
9.2. Interfejs uogólnionej wytwórni abstrakcyjnej .............................................................................251
9.3. Implementacja AbstractFactory ..................................................................................................254
9.4. Implementacja wytwórni abstrakcyjnej z prototypowaniem .......................................................256
9.5. Podsumowanie ............................................................................................................................261
9.6. Szablony AbstractFactory i ConcreteFactory — na skróty .........................................................262
10.
Wzorzec Visitor .........................................................................................265
10.1. Elementarz modelu wizytacji ...................................................................................................265
10.2. Przecienia i metoda wychwytujca .......................................................................................271
10.3. Wizytacja acykliczna ................................................................................................................273
10.4. Uogólniona implementacja wzorca Visitor ...............................................................................278
10.5. Powrót do wizytacji „cyklicznej” .............................................................................................284
10.6. Wariacje ....................................................................................................................................287
10.7. Podsumowanie ..........................................................................................................................290
10.8. Uogólnione komponenty wzorca wizytacji — na skróty ..........................................................290
11.
Wielometody ..............................................................................................293
11.1. Czym s wielometody? .............................................................................................................294
11.2. Przydatno wielometod ...........................................................................................................295
11.3. Podwójne przeczanie — metoda siowa ................................................................................296
11.4. Metoda siowa w wersji automatyzowanej ...............................................................................298
11.5. Symetria rozprowadzania metod siow .................................................................................303
11.6. Rozprowadzanie logarytmiczne ................................................................................................307
11.7. Symetria w FnDispatcher .........................................................................................................312
11.8. Podwójne rozprowadzanie do funktorów .................................................................................313
11.9. Konwertowanie argumentów — statyczne czy dynamiczne? ...................................................316
11.10. Wielometody o staym czasie rozprowadzania .......................................................................321
11.11. BasicDispatcher i BasicFastDispatcher w roli wytycznych ....................................................324
888449913.005.png 888449913.006.png 888449913.007.png
 

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin