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.

Inhaltsverzeichnis

Vorwort von Scott Meyers.	11
Vorwort von John Vlissides.	15
Vorwort.	17
Danksagungen.	23

Teil I	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	SingletonHolder verwenden.	212
6.12	Zusammenfassung.	214
6.13	Das Klassen-Template SingletonHolder 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