lehrerbibliothek.deDatenschutzerklärung
Modernes C++ Design Generische Programmierung und Entwurfsmuster angewendet
Modernes C++ Design
Generische Programmierung und Entwurfsmuster angewendet




Andrei Alexandrescu

mitp-Verlag
EAN: 9783826613470 (ISBN: 3-8266-1347-3)
424 Seiten, paperback, 17 x 24cm, 2003

EUR 34,95
alle Angaben ohne Gewähr

Umschlagtext
"Modernes C++-Design ist ein wichtiges Buch. Es stellt "generische Muster" oder "Mustervorlagen" als leistungsfähige neue Möglichkeit für ein erweiterungsfähiges C++-Design vor, eine neuartige Kombination von Templates und Mustern, die bisher kaum vorstellbar war. Wenn Sie sich professionell mit C++-Design und Programmierung beschäftigen, dann sollten Sie dieses Buch unbedingt lesen, es ist sehr zu empfehlen [...]" Herb Sutter



Mit seinem Buch Modernes C++-Design eröffnet Andrei Alexandrescu dem C++-Programmierer völlig neue Perspektiven und Designtechniken. Mit außerordentlicher Kreativität stellt er eine hochaktuelle

Herangehensweise an das Programmdesign vor, bei der Entwurfsmuster, generische Programmierung und C++ miteinander verbunden werden. Ziel dabei ist es, leistungsstarken, flexiblen und in

höchstem Maße wiederverwendbaren Code zu erstellen.

Das Buch führt das Konzept der generischen Komponenten ein, bei denen es sich um wiederverwendbare Designmuster handelt, die C++-Codebausteine für den Compiler liefern. Generische

Komponenten erzeugen Code, der die ursprüngliche Designintention besser wiedergibt, und unterstützen dadurch die Wiederverwendung von Designstrukturen mit nur wenig Programmieraufwand.



Der Autor beschreibt die spezifischen C++-Techniken und Eigenschaften, die für die Entwicklung generischer Komponenten verwendet werden, und geht über zur Implementierung professioneller generischer Komponenten für den praktischen Einsatz. Immer wieder auftretende Probleme, die C++-Entwickler in ihrer täglichen Arbeit lösen müssen, werden ausführlich behandelt und auf generische

Art gelöst.



Hierzu gehören unter anderem:

• Auf Policies basierendes Design für mehr Flexibilität

• Partielle Template-Spezialisierungen

•Typlisten - leistungsfähige Typmanipulationsstrukturen

• Entwurfsmuster wie zum Beispiel die Muster Visitor, Singleton, Command und die Fabrikmethode

• Multimethoden



Für jede generische Komponente werden die grundlegenden Probleme und Designoptionen vorgestellt und abschließend eine generische Lösung implementiert.



Alle Quellcode-Beispiele können Sie kostenlos aus dem Web downloaden!
Verlagsinfo
Mit diesem Buch zeigt Alexandrescu neue Wege und moderne Designtechniken, die die Elemente Entwurfsmuster, generische Programmierung und C++ vereinen, um flexiblen und wiederverwendbaren Code zu produzieren. Die Kombination dieser Techniken führt dazu, den Designprozess grundlegend zu verbessern und dessen Fexibilität von Anfang an zu erhöhen. Ziel dieses Buches ist es, generische Komponenten zu entwickeln. Diese Komponenten sind im wesentlichen vorbereitete Designbausteine für die Implementierung. Zu deren Haupteigenschaften gehören Anpassungsfähigkeit, Vielseitigkeit und eine leichte Verwendbarkeit. Entwurfsmuster liefern hierzu leistungsstarke, schlüssige und wiederverwendbare Rezepte für Probleme, die in den unterschiedlichsten Zusammenhängen auftreten können. Teil I des Buches beschreibt C++-Techniken und Komponenten für die generische Programmierung. Teil II zeigt darauf aufbauend die Implementierung einer Reihe generischer Komponenten, die in realen Anwendungen eingesetzt werden.
Inhaltsverzeichnis
Vorwort von Scott Meyers 11
Vorwort von John Vlissides 15
Vorwort 17
Danksagungen 23


Teil 1 Techniken 25

1 Policy-basiertes Klassendesign 27
1.1 Die Vielfalt beim Software-Design 27
1.2 Der Irrtum einer universellen Schnittstelle 29
1.3 Mehrfache Vererbung als Ausweg? 30
1.4 Der Vorteil der Templates 31
1.5 Policies und Policy-Klassen 33
1.6 Erweiterte Policies 38
1.7 Destruktoren für Policy-Klassen 39
1.8 Optionale Funktionalität durch unvollständige Instanzen 40
1.9 Policy-Klassen kombinieren 42
1.10 Strukturen mit Policy-Klassen anpassen 44
1.11 Kompatible und inkompatible Policies 45
1.12 Eine Klasse in Policies zerlegen 47
1.13 Zusammenfassung 50

2 Techniken 53
2.1 Compiler-Assertionen 53
2.2 Partielle Template-Spezialisierung 57
2.3 Lokale Klassen 59
2.4 Zuordnung ganzzahliger Konstanten zu Typen 60
2.5 Zuordnung von Typen zu Typen 63
2.6 Typauswahl 65
2.7 Vererbung und Umwandelbarkeit beim Kompilieren erkennen 67
2.8 Wrapper für type_info 71
2.9 NullType und EmptyType 73
2.10 Typ-Traits 74
2.11 Zusammenfassung 84

3 Typlisten 85
3.1 Die Notwendigkeit von Typlisten 85
3.2 Typlisten definieren 87
3.3 Linearisierung der Typlistenerzeugung 89
3.4 Längenberechnung 90
3.5 Intermezzo 91
3.6 Zugriff über den Index 92
3.7 Typlisten durchsuchen 94
3.8 Typlisten ergänzen 95
3.9 Typen aus einer Typliste entfernen 96
3.10 Duplikate löschen 98
3.11 Ein Element der Typliste ersetzen 99
3.12 Partielle Sortierung von Typlisten 100
3.13 Klassen mit Typlisten erzeugen 105
3.14 Zusammenfassung 117
3.15 Typlisten im Überblick 117

4 Small-Object-Allokierung 119
4.1 Der standardmäßige Allokator 120
4.2 Die Funktionsweise eines Speicherallokators 120
4.3 Ein Small-Object-Allokator 123
4.4 Speichereinheiten 124
4.5 Der FixedAllocator 127
4.6 Die SmallObjAllocator-Klasse 132
4.7 Der Trick mit dem Hut 134
4.8 Erst einfach, dann kompliziert und am Ende doch einfach 137
4.9 Allgemeine Hinweise 138
4.10 Zusammenfassung 140
4.11 Der Small-Object-Allokator im Überblick 140

Teil II Komponenten 143

5 Generalisierte Funktoren 145
5.1 Das Befehlsmuster 146
5.2 Das Befehlsmuster in der Praxis 149
5.3 Aufrufbare C++-Entitäten 150
5.4 Das Gerüst des Klassen-Template Functor 151
5.5 Implementierung des weiterleitenden Operators Functor::operator() 157
5.6 Funktoren im Einsatz 159
5.7 Einen Funktor einrichten und gratis einen dazu erhalten 162
5.8 Umwandlungen von Argumenten und Rückgabetypen 163
5.9 Pointer auf Member-Funktionen 165
5.10 Binden 169
5.11 Verkettete Anforderungen 172
5.12 Praktische Erwägungen I: Der Aufwand für weitergeleitete Funktionen 173
5.13 Praktische Erwägungen II: Heap-Allokierung 175
5.14 Rückgängigmachen und Wiederholen mit Funktoren 177
5.15 Zusammenfassung 178
5.16 Funktoren im Überblick 178

6 Singleton-Muster implementieren 181
6.1 Statische Daten + statische Funktionen != Singleton 182
6.2 Die wichtigsten C++-Spracheigenschaften zur Unterstützung von Singleton-Objekten 183
6.3 Die Einzigartigkeit des Singleton-Objekts erzwingen 185
6.4 Das Singleton-Objekt zerstören 186
6.5 Der verwaiste Verweis 189
6.6 Der verwaiste Verweis (I): Das Phoenix-Singleton 191
6.7 Der verwaiste Verweis (II): Singleton-Objekte mit langer Lebensdauer 195
6.8 Singleton-Objekte mit langer Lebensdauer implementieren 198
6.9 Singleton-Objekte in einer Multithread-Umgebung 202
6.10 Schlussfolgerungen 206
6.11 Singleton Holder verwenden 212
6.12 Zusammenfassung 214
6.13 Das Klassen-Template Singleton Holder im Überblick 214

7 Smart-Pointer 217
7.1 Smart-Pointer 218
7.2 Der Vorteil 219
7.3 Speicherung von Smart-Pointern 220
7.4 Smart-Pointer-Member-Funktionen 223
7.5 Strategien für den Umgang mit der Eigentümerschaft 225
7.6 Der Adressoperator 233
7.7 Implizite Umwandlung in einfache Pointertypen 235
7.8 Gleichheit und Ungleichheit 237
7.9 Sortierende Vergleiche 243
7.10 Überprüfungen und Fehlerberichte 247
7.11 Smart-Pointer auf const und const-Smart-Pointer 248
7.12 Arrays 249
7.13 Smart-Pointer und Multithreading 250
7.14 Die Ergebnisse zusammenfügen 255
7.15 Zusammenfassung 262
7.16 SmartPtr im Überblick 263

8 Objektfabriken 265
8.1 Die Notwendigkeit von Objektfabriken 267
8.2 Objektfabriken in C++: Klassen und Objekte 268
8.3 Implementierung einer Objektfabrik 270
8.4 Typidentifizierer 276
8.5 Generalisierung 278
8.6 Details 282
8.7 Klonfabriken 283
8.8 Objektfabriken mit anderen generischen Komponenten verwenden 287
8.9 Zusammenfassung 288
8.10 Das Factory-Klassen-Template im Überblick 289
8.11 Das CloneFactory-Klassen-Template im Überblick 290

9 Die abstrakte Fabrik 293
9.1 Der architektonische Aspekt der abstrakten Fabrik 293
9.2 Eine Schnittstelle für eine generische abstrakte Fabrik 296
9.3 AbstractFactory implementieren 300
9.4 Eine Implementierung der abstrakten Fabrik nach dem Prototypmuster 304
9.5 Zusammenfassung 308
9.6 AbstractFactory und ConcreteFactory im Überblick 309

10 Besucher 313
10.1 Grundlagen des Besuchermusters 314
10.2 Überladung und die alles abfangende Funktion 320
10.3 Eine Verfeinerung der Implementierung: Der azyklische Besucher 322
10.4 Eine generische Implementierung des Besuchermusters 328
10.5 Zurück zum »zyklischen« Besucher 335
10.6 Ansatzpunkte für Varianten 339
10.7 Zusammenfassung 343
10.8 Generische Komponenten des Besuchermusters im Überblick 343

11 Multimethoden 345
11.1 Was sind Multimethoden? 346
11.2 Wann werden Multimethoden benötigt? 347
11.3 Die Rohvariante: Doppelte Umschaltung pro Typ 348
11.4 Automatisierung der rohen Implementierung 351
11.5 Symmetrie bei der rohen Verteilung 357
11.6 Der logarithmische Double-Dispatcher 361
11.7 FnDispatcher und Symmetrie 368
11.8 Double-Dispatch und Funktoren 369
11.9 Argumente umwandeln: static_cast oder dynamic_cast? 372
11.10 Multimethoden mit konstanter Zeit: Ungebremste Geschwindigkeit 378
11.11 BasicDispatcher und BasicFastDispatcher als Policies 382
11.12 Ausblick 383
11.13 Zusammenfassung 385
11.14 Double-Dispatcher im Überblick 386

A Eine minimalistische Multithreading-Bibliothek 391
A.1 Eine kritische Betrachtung des Multithreading 392
A.2 Die Herangehensweise der Loki-Bibliothek 394
A.3 Nicht zu unterbrechende Operationen für ganzzahlige Typen 394
A.4 Mutexe 396
A.5 Sperrsemantik in der objektorientierten Programmierung 398
A.6 Der optionale Typmodifizierer volatile 401
A.7 Semaphoren, Ereignisse und andere Dinge 401
A.8 Zusammenfassung 402

B Loki MSVC 6 und 7 Port 403
B.1 Motivation 403
B.2 Defizite der MSVC-Compiler 404
B.3 Benutzung und Beispiele 411
B.4 Fazit und abschließende Hinweise 413

C Bibliographie 415

Stichwortverzeichnis 417