Produktlinien mit C++-Templates

Transkript

1 Software ubiquitärer Systeme (SuS) Produktlinien mit C++-Templates Olaf Spinczyk AG Eingebettete Systemsoftware Informatik 12, TU Dortmund

2 Inhalt Motivation Templates für Fortgeschrittene Policy-Based Design Synthesizing Objects Zusammenfassung SuS: 06.2 Produktlinien mit C++-Templates 2

3 Motivation Produktlinienkomponenten müssen wiederverwendbar sein statisch/dynamisch konfigurierbar vom Anwendungsfall unabhängig (generisch) formuliert Welche Programmiersprachen-Mechanismen für die generische Programmierung können genutzt werden? ist GP noch besser geeignet als OO oder AO? Analyse am Beispiel von C++-Templates [1, 2] SuS: 06.2 Produktlinien mit C++-Templates 3

4 Inhalt Motivation Templates für Fortgeschrittene Policy-Based Design Synthesizing Objects Zusammenfassung SuS: 06.2 Produktlinien mit C++-Templates 4

5 Fortgeschrittene Templates Template-Parameter Typen, Konstanten und Templates Template-Spezialisierung Fallunterscheidungen zur Übersetzungszeit Template-Metaprogramme Programmierung zur Übersetzungszeit: gezielte Code-Generierung Introspection statische Analyse der vorhandenen Typen und es gibt noch viel mehr SuS: 06.2 Produktlinien mit C++-Templates 5

6 Nicht-Typ Template-Parameter neben Typen können auch konstante Ausdrücke als Template- Parameter benutzt werden Vector2.h template <typename T, int DIM> class Vector2 { T data[dim]; // in jedem Objekt steckt ein Array public: // Konstruktor, Copy-Konstruktor(!),... // Zugriffsfunktionen z.b. mit Indexprüfung: void set (int index, const T& obj); T get (int index) const; aber Achtung: Vector<int> v1(10) Vector<int> v2(20); // v1 und v2 haben den selben Typ Vector2<int,10> v2_1; // v2_1 und v2_2 haben Vector2<int,20> v2_2; // unterschiedliche Typen! SuS: 06.2 Produktlinien mit C++-Templates 6

7 Template-Template-Parameter Templates, die Templates benutzen sollen, können auch Templates als Parameter bekommen DataCollector.h template <template <typename> class Container> class DataCollector { Container<double> collected_data; // Container wird benutzt public: //... so wird s benutzt: Parameter ist ein Template mit einem Parameter DataCollector<Vector> dc; DataCollector<Vector2> dc2; // alles OK // geht nicht! // (Vector2 erwartet 2 Parameter) SuS: 06.2 Produktlinien mit C++-Templates 7

8 Default Template-Parameter ähnlich wie bei Default-Argumenten von Funktionen können auch Template-Parameter ein Default haben wie bei Funktionen müssen dann nachfolgende Parameter auch ein Default haben zwei Parameter mit Defaults DataCollector2.h template <template <typename,int> class Container=Vector2, int DIM=32> class DataCollector2 { Container<double, DIM> collected_data; // Container und DIM public: //... so wird s benutzt: DataCollector2<> c1; // auf <> kann man nicht verzichten DataCollector2<Vector2> c2; // DIM ist 32 per Default DataCollector2<FooBar, 10> c3; // Default nicht genutzt SuS: 06.2 Produktlinien mit C++-Templates 8

9 Template-Spezialisierung mit Hilfe der Template-Spezialisierung können unterschiedliche Template-Implementierungen in Abhängigkeit von den Parametern gewählt werden Explizite Template-Spezialisierung für einen bestimmten Parametersatz, z.b. Vector<bool> Partielle Template-Spezialisierung für eine Parametermenge, z.b. Vector<const T*> mit beliebigem T geht nicht bei Funktions-Templates wenn sowohl eine explizite als auch eine partielle Spezialisierung passen, wird die explizite gewählt passt keine Spezialisierung, wird das primäre Template genommen Template-Spezialisierung bewirkt eine Fallunterscheidung wichtige Grundlage für Template-Metaprogrammierung SuS: 06.2 Produktlinien mit C++-Templates 9

10 Explizite Template-Spezialisierung kann z.b. zur Optimierung benutzt werden: Vector.h template <> explizite Spezialisierung für bool class Vector<bool> { unsigned *data; // bool wird als Bit gespeichert int dim; public: // Konstruktor Vector(int d) { data = new unsigned[1 + (d-1) / (sizeof(unsigned)*8)]; } // Copy-Konstruktor(!), Zugriffsfunktionen,... mit der Spezialisierung für bool wird für Vector<bool> auf dem Heap nur ein Achtel des Speicherplatzes angefordert SuS: 06.2 Produktlinien mit C++-Templates 10

11 Partielle Template-Spezialisierung kann z.b. die gleiche Optimierung für Vector2 realisieren: Vector2.h template <int DIM> partielle Spezialisierung für bool und beliebige DIMension class Vector2<bool, DIM> { typedef unsigned storage_t; static const unsigned BITS = sizeof(storage_t) * 8; storage_t data[1 + (DIM - 1) / BITS]; public: // Konstruktor, Copy-Konstruktor(!),... // Zugriffsfunktionen z.b. mit Indexprüfung: void set (int index, bool obj) { if (obj) data[index / BITS] = (1 << (index % BITS)); else data[index / BITS] &= ~(1 << (index % BITS)); } // SuS: 06.2 Produktlinien mit C++-Templates 11

12 Template-Metaprogramme (1) durch rekursive Template-Instanziierung und Template- Spezialisierung können zur Übersetzungszeit Fallunterscheidungen und Schleifen ausgeführt werden: Fac.h // Fac<I>: instanziiert Fac<I-1> rekursiv template<int I> struct Fac { enum { RES = I * Fac<I-1>::RES // Spezialisierung für <0>: terminiert die Meta-Schleife template <> struct Fac<0> { enum { RES = SuS: 06.2 Produktlinien mit C++-Templates 12

13 Template-Metaprogramme (2) zur Übersetzungszeit ausgeführte Berechnungen kosten zur Laufzeit nichts: main: pushl %ebp movl %esp, %ebp pushl $5040 pushl $.LC0 main.cc call printf #include <stdio.h> leave #include "fac.h" xorl %eax, %eax ret int main () { printf ("%d\n", Fac<7>::RES); // hier entsteht eine // Instanziierungskette! } im generierten Assembler-Code steht das Ergebnis (5040) bereits fest! mit Metaprogrammen lässt sich praktisch alles berechnen: die Sprache ist Turing-vollständig SuS: 06.2 Produktlinien mit C++-Templates 13

14 Introspection mittels Template-Spezialisierung und dem Overload- Resolution-Mechanismus kann man zur Übersetzungszeit vieles über vorhandene Typen herausfinden, z.b.: template <typename Base> struct InheritDetector { typedef char (&no)[1]; typedef char (&yes)[2]; static yes test(base *); // Resultatsgröße ist 1 static no test(...); // Resultatsgröße ist 2 template <typename Derived, typename Base> struct Inherits { typedef Derived *DP; // sizeof ermittelt die Größe des Resultatsobjekts enum { RET = sizeof(inheritdetector<base>::test(dp())) == sizeof(typename InheritDetector<Base>::yes) SuS: 06.2 Produktlinien mit C++-Templates 14

15 Inhalt Motivation Templates für Fortgeschrittene Policy-Based Design Synthesizing Objects Zusammenfassung SuS: 06.2 Produktlinien mit C++-Templates 15

16 Policy-Based Design [3] Problemfeld Entwurfsentscheidungen wie man es macht, macht man es falsch Lösungen können je nach Anwendungsfall mehr oder weniger (oder gar nicht) geeignet sein Entscheidung sollte nicht beim Entwickler einer Klasse liegen, sondern beim Anwender Ziel: Klassen konfigurierbar gestalten Schaffung einer Auswahlmöglichkeit für verschiedene Verhaltensweisen durch den Anwender SuS: 06.2 Produktlinien mit C++-Templates 16

17 Idee von Policy-based Design Klassen mit komplexem Verhalten werden in eine Host-Klasse und mehrere kleinere Policy-Klassen zerlegt jede Policy kapselt einen Belang der Host-Klasse Verbindung der komplexen Host-Klasse mit den Policy-Klassen über C++-Templates Policies sind vom Benutzer der Klasse auswählbar der Benutzer kann also das Verhalten der Host-Klasse durch geeignete Auswahl von Policy-Klassen anpassen SuS: 06.2 Produktlinien mit C++-Templates 17

18 Beispiel: NewCreator ist ein Klassen-Template, das neue Objekte erzeugt: template <class T> class NewCreator { public: static T *create() { return new T; }... Widget *w = NewCreator<Widget>::create(); NewCreator erzeugt alle Objekte mit new in manchen Fällen könnte anderes Verhalten erwünscht sein SuS: 06.2 Produktlinien mit C++-Templates 18

19 Beispiel: MallocCreator Alternative zum NewCreator MallocCreator fordert Speicher mit malloc() an Objekt wird mit Placement New in den Speicher gelegt template <class T> class MallocCreator { public: static T *create() { void *buf = malloc(sizeof(t)); if (!buf) return 0; // oder Exception werfen return new(buf) T; // placement new }... Widget *w = MallocCreator<Widget>::create(); SuS: 06.2 Produktlinien mit C++-Templates 19

20 Beobachtung MallocCreator und NewCreator besitzen dieselbe Schnittstelle beide verfügen über die Methode create(), die ein neues Objekt erstellen soll eine gemeinsame abstrakte Basisklasse, die die gemeinsame Schnittstelle manifestieren würde, gibt es aber nicht NewCreator lässt sich trotzdem im Quellcode durch MallocCreator ersetzen statische Polymorphie SuS: 06.2 Produktlinien mit C++-Templates 20

21 Der Begriff Policy Policies sind Schnittstellen für konfigurierbare Belange einer Klasse Policy-Klassen implementieren die von der Policy vorgegebene Schnittstelle Beispiel: Creation Policy kapselt das Erstellen von neuen Objekten Schnittstelle besteht aus der Methode create(), welche ein neues Objekt erzeugen soll Templates NewCreator und MallocCreator sind mögliche Policy- Klassen; es sind aber noch weitere denkbar SuS: 06.2 Produktlinien mit C++-Templates 21

22 Verwenden der Policy Policy-Klassen werden bei der Übersetzung mittels Template- Parameter in die Host-Klasse eingebunden Beispiel: WidgetManager template <class CreationPolicy> class WidgetManager { public: void newwidget() { Widget *w = CreationPolicy::create();... } SuS: 06.2 Produktlinien mit C++-Templates 22

23 Auswahl der Policy-Klasse Anwender von WidgetManager können die Creation Policy nun auswählen: Mit NewCreator: typedef WidgetManager<NewCreator<Widget> > WM; oder mit dem MallocCreator: typedef WidgetManager<MallocCreator<Widget> > WM; Problem: Man muss immer Widget mit angeben, obwohl klar ist, dass der WidgetManager Widgets anlegen will SuS: 06.2 Produktlinien mit C++-Templates 23

24 Template-Template-Parameter Lösung: Host-Klasse bekommt die Policy-Klasse als Template-Template-Parameter übergeben: einfacher zu lesen weniger fehleranfällig: Benutzer gibt den Objekttyp nicht selbst an flexibler: WidgetManager kann auch andere Objekte erzeugen template <template <class> class CreationPolicy> class WidgetManager { public: void newwidget() { Widget *w = CreationPolicy<Widget>:create();... }... // jetzt kompakter und einfacher: typedef WidgetManager<NewCreator> WM; SuS: 06.2 Produktlinien mit C++-Templates 24

25 Weitere Möglichkeiten die Struktur der Host-Klasse ist durch Erben von der Policy- Klasse erweiterbar Host erbt Member-Variablen von den Policies Policies können zusätzliche Methoden in die Host-Klasse einbringen ( Enriched Policies ) Policies sind so nicht nur auf Verhalten beschränkt SuS: 06.2 Produktlinien mit C++-Templates 25

26 Entwurf einer Klasse mit Policies Auswahl der Policies Entscheiden, welche Belange durch Policies realisiert werden Schwierige Entwurfsentscheidungen in Policies auslagern bei mehreren Policies: möglichst orthogonale Semantik definieren Konsequenzen Policies müssen beim Entwurf der Host-Klasse festgelegt werden! nachträgliche Einführung zusätzlicher Policies schwierig (im Gegensatz zur Einführung weiterer Policy-Klassen) Policy ist im Code der Host-Klasse verankert join points sind damit explizit vorgegeben keine gute Möglichkeit zur Modularisierung querschneidender Belange SuS: 06.2 Produktlinien mit C++-Templates 26

27 Fazit Policy-based Design erlaubt die getrennte Realisierung konfigurierbarer Belange in Form von Policies ermöglicht flexible Klassen, deren Verhalten der Anwender an seine Bedürfnisse anpassen kann basiert auf Sprachelementen von C++ Templates Template-Template-Parameter ein größeres Anwendungsbeispiel jetzt: Synthesizing Objects SuS: 06.2 Produktlinien mit C++-Templates 27

28 Inhalt Motivation Templates für Fortgeschrittene Policy-Based Design Synthesizing Objects Zusammenfassung SuS: 06.2 Produktlinien mit C++-Templates 28

29 Synthesizing Objects [4] Welche Programmiersprachen-Mechanismen für die generische Programmierung können genutzt werden? C++-Templates! Wie beschreibt man Variabilität auf einem problemadäquaten abstrakten Niveau? Merkmalmodelle! Merkmal-getriebene Generierung mittels Templates SuS: 06.2 Produktlinien mit C++-Templates 29

30 Beispielszenario Merkmale eine Familie von Listen-Klassen List [ElementType] Ownership Morphology LengthCounter Tracing external reference owned reference copy polymorphic monomorphic [LengthType]... int short long SuS: 06.2 Produktlinien mit C++-Templates 30

31 Beispielszenario Architektur in Form einer (erweiterten) funktionalen Hierarchie optionale Merkmale werden optionale obere Schichten weitere Variabilität durch Konfigurierbarkeit der Schichten Basisschicht mit Konfigurationswissen Tracing Layer Counter Layer BasicList Config TracedList LenList PtrList Configuration Repository: Stellt Konfigurationsinformationen in Form von Typen zur Verfügung. Minimiert Abhängigkeiten zwischen den Schichten. ElementType : [ElementType] Destroyer : EmptyDestroyer ElementDestroyer TypeChecker : DynamicTypeChecker EmptyTypeChecker Copier : PolymorphicCopier MonomorphicCopier EmptyCopier LengthType : int short long... ReturnType SuS: 06.2 Produktlinien mit C++-Templates 31

32 PtrList (1) Daten und Typen template <class Config_> class PtrList { public: // Config als Member-Typ zur Verfügung stellen: typedef Config_ Config; private: // Weitere Typen aus dem Configuration Repository: typedef typename Config::ElementType ElementType; typedef typename Config::SetHeadElementType SetHeadElementType; typedef typename Config::ReturnType ReturnType; // Diese Typen repräsentieren Policies! typedef typename Config::Destroyer Destroyer; typedef typename Config::TypeChecker TypeChecker; typedef typename Config::Copier Copier; private: // Datenelemente ElementType *head_; // jede Liste speichert einen Zeiger auf 1 Element ReturnType *tail_; // weitere Elemente stecken in der Liste tail_ public: // Methoden (siehe nächste Folie) SuS: 06.2 Produktlinien mit C++-Templates 32

33 PtrList (2) Methoden // Konstruktor: erzeugt eine neue Liste PtrList(SetHeadElementType &h, ReturnType *t=0) : head_(0), tail_(t) { sethead(h); } // Destruktor: ggf. das referenzierte Element löschen ~PtrList() { Destroyer::destroy (head_); } // Initialisierung des Elements: ggf. Typprüfung und Kopie void sethead(setheadelementtype &h) { TypeChecker::check(h); head_ = Copier::copy(h); } // Setter- und Getter-Funktionen ElementType &head() { return *head_; } void settail(returntype *t) { tail_ = t; } ReturnType *tail() const { return tail_; } wozu eigentlich SetHeadElementType&? je nachdem, ob die Elemente kopiert werden, ist das ElementType& oder const ElementType& SuS: 06.2 Produktlinien mit C++-Templates 33

34 Policies (1) Destroyer template <class ElementType> struct ElementDestroyer { static void destroy(elementtype *e) { delete e; // Heap speicher wird freigegeben, Destruktor ausgeführt } template <class ElementType> struct EmptyDestroyer { static void destroy(elementtype *e) { // NICHTS! } der ElementDestroyer muss verwendet werden, wenn die Liste Elemente vor dem Einfügen kopiert Aufrufe von EmptyDestroyer::destroy() kann der Optimierer komplett eliminieren! SuS: 06.2 Produktlinien mit C++-Templates 34

35 Policies (2) TypeChecker template <class ElementType> struct DynamicTypeChecker { static void check(const ElementType &e) { // Typüberprüfung mittels RTTI zur Laufzeit (Debug-Modus) assert(typeid(e) == typeid(elementtype)); } template <class ElementType> struct EmptyTypeChecker { static void check(const ElementType &e) { // NICHTS } der DynamicTypeChecker sorgt dafür, dass alle Elemente der Liste den selben Typ haben (monomorphic list) und noch eine Klasse, die NICHTS tut SuS: 06.2 Produktlinien mit C++-Templates 35

36 Policies (3) Copier template <class ElementType> struct PolymorphicCopier { static ElementType *copy(const ElementType &e) { return e.clone(); // Kopieren mittels einer virtuellen Methode } template <class ElementType> struct MonomorphicCopier { static ElementType *copy(const ElementType &e) { return new ElementType(e); // Kopieren mittels Copy-Konstruktor } template <class ElementType> struct EmptyCopier { static ElementType *copy(elementtype &e) { return &e; // liefert einfach das Original } SuS: 06.2 Produktlinien mit C++-Templates 36

37 Zwischenfazit Traits & Policies unser PtrList-Template ist hochgradig generisch: variable Aktivitäten werden durch Policies realisiert der Zugriff auf die richtige Policy-Klasse wird über das Configuration Repository gesteuert: eine Traits-Klasse was sind Traits und Policies? Traits represent natural additional properties of a template parameter Policies represent configurable behavior for generic functions and types D. Vandevoorde and M. Josuttis C++ Templates: The Complete Guide SuS: 06.2 Produktlinien mit C++-Templates 37

38 LenList optionale Wrapper-Klasse 1 template <class BaseList> class LenList : public BaseList { // Template-Parameter wird Basisklasse public: // Ermittlung des Configuration Repository typedef typename BaseList::Config Config; private: // Ermittlung weiterer Typen aus dem Configuration Repository: typedef typename Config::ElementType ElementType; typedef typename Config::SetHeadElementType SetHeadElementType; typedef typename Config::ReturnType ReturnType; typedef typename Config::LengthType LengthType; private: // Datenelemente LengthType length_; // Anzahl der Elemente in der Liste public: // Methoden: Erweiterungen zur Verwaltung der Länge... LenList(SetHeadElementType &h, ReturnType *t=0) : BaseList(h,t), length_(computedlength()) {} void settail(returntype *t) { BaseList::setTail(t); length_ = computedlength(); } const LengthType &length() const { return length_; } LengthType computedlength() const { return tail()? tail()->length()+1 : 1; } SuS: 06.2 Produktlinien mit C++-Templates 38

39 TracedList optionaler Wrapper 2 template <class BaseList> class TracedList : public BaseList { // Template Parameter wird Basisklasse public: // Ermittlung des Configuration Repository typedef typename BaseList::Config Config; private: // Ermittlung weiteree Typen aus dem Configuration Repository: typedef typename Config::ElementType ElementType; typedef typename Config::SetHeadElementType SetHeadElementType; typedef typename Config::ReturnType ReturnType; public: // Methoden: Wrapper zur Ausgabe des Funktionsnamens TracedList(SetHeadElementType &h, ReturnType *t=0) : BaseList(h,t) {} void sethead(setheadelementtype &h) { cout << "sethead(" << h << ")" << endl; BaseList::setHead(h); } ElementType &head() { cout << "head()" << endl; return BaseList::head(); } void settail(returntype *t) { cout << "settail(t)" << endl; BaseList::setTail(t); } SuS: 06.2 Produktlinien mit C++-Templates 39

40 Konfigurierung Variante 1... erfolgt durch Anlegen eines Configuration Repository struct TracedCopyMonoPersonLenListConfig { // typedefs, die von den Komponenten benötigt werden typedef Person ElementType; typedef const ElementType SetHeadElementType; typedef int LengthType typedef ElementDestroyer<ElementType> Destroyer; typedef DynamicTypeChecker<ElementType> TypeChecker; typedef MonomorphicCopier<ElementType> Copier; // PtrList wird in LenList und TracedList verpackt typedef Weg der Konfigurationsinformationen TracedList< LenList< PtrList<TracedCopyMonoPersonLenListConfig> > > ReturnType; // und nun noch ein kürzerer Name... typedef TracedCopyMonoPersonLenListConfig::ReturnType MyList1; SuS: 06.2 Produktlinien mit C++-Templates 40

41 Konfigurierung Variante 2... oder z.b. so: struct RefPolyPersonListConfig { // typedefs, die von den Komponenten benötigt werden typedef Person ElementType; typedef ElementType SetHeadElementType; typedef EmptyDestroyer<ElementType> Destroyer; typedef EmptyTypeChecker<ElementType> TypeChecker; typedef EmptyCopier<ElementType> Copier; // PtrList wird direkt verwendet typedef PtrList<RefPolyPersonListConfig> ReturnType; // und nun noch ein kürzerer Name... typedef RefPolyPersonListConfig::ReturnType MyList2; SuS: 06.2 Produktlinien mit C++-Templates 41

42 Zwischenfazit mit Hilfe von unterschiedlichen Configuration Repositories lassen sich 24 verschiedene Listentypen erzeugen wer erstellt die Configuration Repositories? der Listen-Entwickler bei 24 Varianten gerade noch machbar, bei tausenden nicht! der Anwender der Listen Antwort: mühsam und fehlerträchtig viel Wissen über interne Strukturen nötig Konfigurierung durch den Anwender auf abstrakter Ebene mit Hilfe der Merkmale das Configuration Repository muss generiert werden; das ist die Aufgabe des Configuration Generator Template-Metaprogrammierung! SuS: 06.2 Produktlinien mit C++-Templates 42

43 Der Configuration Generator (1)... erwartet Merkmale als Eingabe: enum Ownership { ext_ref, own_ref, cp enum Morphology { mono, poly enum CounterFlag { with_counter, no_counter enum TracingFlag { with_tracing, no_tracing... basiert auf einem kleinen Hilfs-Template: template <bool cond, class ThenType, class ElseType> struct IF { typedef ThenType RET; // Spezialisierung für false template <class ThenType, class ElseType> struct IF<false, ThenType, ElseType> { typedef ElseType RET;... und wird so benutzt: ganz einfach! typedef LIST_GENERATOR<Person, ext_ref, poly>::ret MyList3; SuS: 06.2 Produktlinien mit C++-Templates 43

44 Der Configuration Generator (2) template < class ElementType_ = int, Ownership ownership = cp, Morphology morphology = mono, CounterFlag counterflag = no_counter, TracingFlag tracingflag = no_tracing, class LengthType_ = int> class LIST_GENERATOR { public: typedef LIST_GENERATOR<ElementType_, ownership,...> Generator; private: // Konfigurierungslogik wird durch IFs ausgedrückt... typedef IF<ownership==cp ownership==own_ref, ElementDestroyer<ElementType_>, EmptyDestroyer<ElementType_> >::RET Destroyer_; typedef IF<morphology==mono, DynamicTypeChecker<ElementType_>, EmptyTypeChecker<ElementType_> >::RET TypeChecker_;... typedef PtrList<Generator> List; typedef IF<counterFlag==with_counter, LenList<List>, List>::RET List_with_counter_or_not; typedef IF<tracingFlag==with_tracing, TracedList<List_with_counter_or_not>, List_with_counter_or_not>::RET List_with_tracing_or_not; // öffentliche Typen... (nächste Seite) SuS: 06.2 Produktlinien mit C++-Templates 44

45 Der Configuration Generator (3) public: // öffentliche Typen typedef List_with_tracing_or_not RET; struct Config { typedef ElementType_ ElementType; typedef SetHeadElementType_ SetHeadElementType;... typedef RET ReturnType; da Config jetzt eine generierte Klasse im Generator ist, muss die PtrList-Klasse minimal angepasst werden. template <class Generator> class PtrList { public: typedef typename Generator::Config Config; // der Rest wie gehabt SuS: 06.2 Produktlinien mit C++-Templates 45

46 Inhalt Motivation Templates für Fortgeschrittene Policy-Based Design Synthesizing Objects Zusammenfassung SuS: 06.2 Produktlinien mit C++-Templates 46

47 Zusammenfassung C++-Templates bilden das notwendige Handwerkszeug, um mit C++ generisch zu programmieren Merkmalmodelle bilden das Handwerkszeug, um Variabilität von Produktlinien zu beschreiben in Synthesizing Objects verbinden U. Eisenecker und K. Czarnecki beide Techniken Trennung der Belange durch Configuration Repositories und Configuration Generators Anwendung der Template-Metaprogrammierung und von Policy-Based Design der Ansatz erfordert, dass man die Nachteile der Programmierung mit C++-Templates in Kauf nimmt Fehlermeldungen, Übersetzungszeiten, Syntax, SuS: 06.2 Produktlinien mit C++-Templates 47

48 Literatur [1] D. Vandevoorde, N.M. Josuttis, C++ Templates: The Complete Guide. Addison-Wesley, 2003, ISBN [2] The C++ Standard BS ISO/IEC 14882:2003 (Second Edition). John Wiley & Sons, Ltd., 2003, ISBN [3] A. Alexandrescu, Modern C++ Design Generic Programming and Design Patterns Applied. Addison-Wesley, 2002, ISBN [4] K. Czarnecki und U. Eisenecker, Synthesizing Objects. Concurrency: Practice and Experience, John Wiley & Sons, Ltd SuS: 06.2 Produktlinien mit C++-Templates 48