Real-Life Template Meta-Programmierung

Transkript

1 Meeting C Real-Life Template Meta-Programmierung Detlef Wilkening / 85

2 Einleitung Es geht los Typ-Container Typ-Funktionen Passende Typen Funktions-Existenz Fazit Literatur 2 / 85

3 Einleitung 3 / 85

4 Was meint eigentlich "Meta-Programmierung"? Der Programmierer schreibt nicht selber das Programm Sondern er "beschreibt" nur, was er gerne hätte Ein "Generator" generiert dann, was er möchte Im Idealfall also ein "Do, what I mean Button" Aber davon sind wir noch sehr weit entfernt 4 / 85

5 Warum will man das machen? Einfacherer Code Denn ich muß nicht alles hinschreiben Wartbarer und lesbarer Code Denn ich muß mich nicht um alle Details kümmern und kann auf einem "höheren Level" programmieren Performanterer und speichereffizienterer Code Denn der Generator weiß mehr als ich und behält den Überblick und generiert den "optimalen Code" 5 / 85

6 Für uns (in C++) sehr wichtig: Der Generator arbeitet zur Entwicklungs-Zeit Nicht zur Laufzeit Denn ansonsten ist das Ergebnis nicht performant und speichersparend Zur Laufzeit kann man auch sehr schöne Meta-Dinge machen Aber die sind meist langsam und speicherfressend 6 / 85

7 Generatoren gibt es viele Modell-Orientiertes Programmieren ist ja Hype Gerade auch im Java/Eclipse Umfeld Sicher auch woanders Gibt sogar ganze Lehrstühle die daraus ihre Berechtigung beziehen Aber extra Generatoren sind hier nicht unser Thema In C++ sind zwei Entwicklungs-Zeit Generatoren eingebaut Teil jedes C++ Compilers Präprozessor C++ Template Mechanismen 7 / 85

8 Präprozessor Beschränkt in seinen Fähigkeiten Kennt die Sprache nicht Ignoriert viele Sprach-Elemente Läuft noch vor dem eigentlichen Compiler ab Ist mehr ein intelligentes Find&Replace auf Text-Basis Kann aber -im Gegensatz zu Templates -gut mit Texten umgehen Hat von daher auch seine Einsatz-Bereiche In Boost gibt es die "Preprocessor Metaprogramming Lib" Wir wollen den Präprozessor hier aber ignorieren Obwohl er einige Beispiele in realem Code vereinfachen könnte 8 / 85

9 C++ Template-Mechanismen Mechanismus in der Sprache C++, der Parameter (meist Typ-Parameter) bekommt und dann nach festen Regeln aus der Vorlage (dem Template-Code) unter Berücksichtigung der Sprach-Regeln Code generiert. Dies gilt schon für einfachste Funktions-Templates template<class T> T min(t lhs, T rhs) { return lhs<rhs? lhs : rhs; } 9 / 85

10 Es gibt auch Leute Die reden schon bei einfachsten Templates von Template Meta-Programmierung Und irgendwie haben sie ja auch Recht Aber keine Angst Ich will Sie nun nicht mit einfachstem Template-Code langweilen Spezialisierungen sollten sie schon kennen Aber keine Angst Es wird auch nicht ganz schlimm Das würde ich ja selber nicht verstehen Ganz im Gegenteil Etwas tiefergehende Template-Kenntnisse wie z.b. Template / 85

11 Für mich beginnt Meta-Programmierung da, Wo mehr passiert als einfach nur Typ-Parameter durch Typ-Argumente zu ersetzen Das hätte ja auch schon der Präprozessor halbwegs gekonnt Für mich heißt Meta-Programmierung Ich programmiere Entscheidungen oder Iterationen Die dann aber zur Entwicklungs-Zeit ausgewertet werden Und abhängig von denen unterschiedlicher Code erzeugt wird Eben Meta Programmierung Das geht, da C++ Templates Turing-Complete sind Daher es gibt z.b. Entscheidungen, und via Rekursion auch Iterationen 11 / 85

12 Template Meta-Programmierung in den meisten Lehrbüchern Fast alle C++ Lehrbücher stellen heute TMP vor Gut :-) Meist an dem typischen Fakultäts-Beispiel Berechnung der Fakultät zur Compile-Zeit Schauen wir uns das einmal an 12 / 85

13 template<int N> struct Factorial { static const int value = N * Factorial<N-1>::value; }; template<> struct Factorial<1> { static const int value = 1; }; 13 / 85

14 int main() { cout << Factorial<1>::value << endl; // => 1 cout << Factorial<2>::value << endl; // => 2 cout << Factorial<3>::value << endl; // => 6 cout << Factorial<4>::value << endl; // => 24 cout << Factorial<5>::value << endl; // => 120 cout << Factorial<6>::value << endl; // => 720 cout << Factorial<7>::value << endl; // => 5040 cout << Factorial<8>::value << endl; // => } 14 / 85

15 Gar keine Frage Das ist Template Meta-Programmierung Die Fakultät wird rekursiv (die funktionale Schleife) berechnet Und über Spezialisierung als "If" wird das Rekursions-Ende erkannt und dann abgebrochen 15 / 85

16 Aber mal ehrlich Wer hat je die Fakultät zur Compilezeit berechnet benötigt? Das ist eher selten der Fall Ja, ich kann mir auch Fälle vorstellen - aber im Normalfall Didaktisch ist das eher Unsinn Wie Rekursion anhand der Fakultät einzuführen Und dann sagt man den Studenten direkt Bitte implementiert die Fakultät nicht so Nehmt lieber eine Schleife Was denkt der Student dann? "Muß wohl wirklich ein sinnvolles Feature sein" 16 / 85

17 So ging es mir auch vor Jahren mit TMP Und das ist meine Motivation für den Vortrag Ein bisschen zu zeigen, was man im "Real-Life" mit Template-Meta-Programmierung machen kann Das was im Rahmen des Vortrags möglich ist Und noch ein Hinweis bevor es los geht Alle diese Beispiele kann man auch anders mit implementieren Auch TMP ist Programmierung und da führen viele Wege zum Ziel Ich habe versucht, die einfachsten Wege zu nutzen Andere sind aber leistungsfähiger, flexibler, allgemeiner, Mir ging es hier um "Einfachheit um relative Einfachheit Also nicht wundern, wenn Sie das woanders anders sehen 17 / 85

18 Es geht los 18 / 85

19 Lassen Sie uns mit dem ersten Real-Life Beispiel anfangen Aber vorher müssen wir einige Grundlagen kennen lernen Typ-Listen und Typ-Arrays Templates "rechnen" in erster Linie mit Typen Und darum müssen wir erstmal lernen, Typen zu "speichern" und Typ-Mengen zu bearbeiten 19 / 85

20 Typ-Paare Die einfachste Form, zwei unterschiedlich Typen zu speichern ist das Typ-Paar template<class T1, class T2> struct TypePair { typedef T1 Type1; typedef T2 Type2; }; 20 / 85

21 Aus der funktionalen Programmierung wissen wir Mit Typ-Paaren kann man eine Liste aufbauen Eine Liste besteht aus dem Kopf (-Typ) und dem Rest (Typen) Außerdem muß es noch einen speziellen Abschluß Typ geben Verzeigerung auf das nächste Element ist "Null" 21 / 85

22 struct End {}; template<class T1, class T2> struct TypePair { typedef T1 Head; typedef T2 Tail; }; [int, long, bool] => typedef TypePair<int, TypePair<long, TypePair<bool, End>>> tl; => tl.tail.head <=> "long" 22 / 85

23 Typ-Listen Bauen sich rekursiv auf Können dadurch beliebig lang werden Sind für unsere einfachen Beispiele leider etwas zu kompliziert Darum nehmen wir jetzt lieber Typ-Arrays Typ-Arrays Template mit max. Aufnahme von Typen In unserem Beispiel für die Übersichtlichkeit bis zu 5 Typen Nicht genutzte Typen werden mit "Empty" belegt 23 / 85

24 struct Empty {}; template< class T0 = Empty, class T1 = Empty, class T2 = Empty, class T3 = Empty, class T4 = Empty> struct TypeArray { }; typedef T0 Type0; typedef T1 Type1; typedef T2 Type2; typedef T3 Type3; typedef T4 Type4; 24 / 85

25 Was kann man nun mit Typ-Arrays machen? Z.B. auf den n-ten Typ zugreifen Vergleichbar dem Index-Zugriff [] in ein Array oder Vektor Hierfür gibt es viele Lösungs-Möglichkeiten Wir schauen uns einmal 2 typische Lösungen an At1 & At2 At1 Nutzt die Spezialisierung auf den Index Funktioniert nur mit Typ-Arrays At2 Ist funktional umgesetzt Funktioniert in analoger Form auch für Typ-Listen Achtung - wir kümmern uns nicht um Fehler-Behandlung Gilt für alle Beispiele, sprengt unseren Rahmen 25 / 85

26 template<class T, size_t Idx> struct At1 { }; template<class T> struct At1<T, 0> { typedef typename T::Type0 Type; }; template<class T> struct At1<T, 1> { typedef typename T::Type1 Type; }; 26 / 85

27 template<class T> struct At1<T, 2> { typedef typename T::Type2 Type; }; template<class T> struct At1<T, 3> { typedef typename T::Type3 Type; }; template<class T> struct At1<T, 4> { typedef typename T::Type4 Type; }; 27 / 85

28 typedef TypeArray<short, int, long> TA; cout << "TA[0]: " << typeid(at1<ta, 0>::Type).name(); cout << "TA[1]: " << typeid(at1<ta, 1>::Type).name(); cout << "TA[2]: " << typeid(at1<ta, 2>::Type).name(); => TA[0]: short TA[1]: int TA[2]: long 28 / 85

29 Für die funktionale Lösung "At2" benötigen wir 2 Hilfen GetHead Gib den ersten Typ zurück GetTail Gib den Rest des Typ-Arrays zurück Natürlich als Typ-Array Also alles ausser dem ersten Element 29 / 85

30 template<class T> struct GetHead { typedef typename T::Type0 Type; }; template<class T> struct GetTail { typedef TypeArray < typename T::Type1, typename T::Type2, typename T::Type3, typename T::Type4 > Type; }; 30 / 85

31 cout << typeid(gethead<ta>::type).name(); cout << typeid(gettail<ta>::type).name(); cout << typeid(gethead<gettail<ta>::type>::type).name(); cout << typeid(gethead<gettail<gettail<ta>::type>::type>::type).name(); => short TypeArray<int,long,Empty,Empty,Empty> int long 31 / 85

32 Mit GetHead und GetTail läßt sich jetzt "At2" einfach implementieren template<class T, size_t Idx> struct At2 { typedef typename At2<typename GetTail<T>::Type, Idx-1>::Type Type; }; template<class T> struct At2<T, 0> { typedef typename GetHead<T>::Type Type; }; 32 / 85

33 typedef TypeArray<short, int, long> TA; cout << "TA[0]: " << typeid(at2<ta, 0>::Type).name(); cout << "TA[1]: " << typeid(at2<ta, 1>::Type).name(); cout << "TA[2]: " << typeid(at2<ta, 2>::Type).name(); => TA[0]: short TA[1]: int TA[2]: long 33 / 85

34 Vergleichbar zu "At", "GetHead" und "GetTail" lassen sich auch andere Funktionalitäten implementieren Reverse PushFront, PushBack Erase Find Wie STL Algorithmen Aber das machen wir jetzt nicht Viel mehr als das Bisherige brauchen wir für unsere Beispiele nicht 34 / 85

35 Eins fehlt uns noch für unser Real-Life Beispiel Eine If-Abfrage Natürlich zur Compile-Zeit Daher sind die True-und False-Zweige keine Zweige sondern True- und False-Typen Die Bedingung ist natürlich weiterhin ein Boolscher-Ausdruck Aber Achtung Die muß zur Compile-Zeit auswertbar sein Also kein Laufzeit-Ausdruck 35 / 85

36 template<bool Expr, class TrueType, class FalseType> struct TypeIf { typedef TrueType Type; }; template<class TrueType, class FalseType> struct TypeIf<false, TrueType, FalseType> { typedef FalseType Type; }; 36 / 85

37 cout << typeid( TypeIf<sizeof(char)==1, int, double>::type).name() << endl; cout << typeid(typeif<sizeof(int)==1, int, double>::type).name() << endl; => int double 37 / 85

38 So, jetzt haben wir alles zusammen für das wahre Leben Sie kennen das alle: In C++ ist die Größe der elementaren Datentypen nicht festgelegt Nur "char" ist 1 Byte groß Aber wie groß ist ein Byte? Diese Frage wollen wir hier erstmal ignorieren Jetzt wollen Sie wirklich portablen Code schreiben Und Sie benötigen einen Typ mit genau 2 Byte Welchen nehmen Sie? Hier kann der Compiler helfen Denn er kennt die Größen der Typen Wir müssen ihm nur sagen, was er nehmen soll Fangen wir mit diesmal mit dem Ergebnis an: Wir betrachten hier nur Signed-Typen! Unsigned und andere Dinge sind Erweiterungen für Sie zuhause ;-) 38 / 85

39 cout << "signed char: " << sizeof(signed char) << " - " << typeid(signed char).name() << endl; cout << "short: " << sizeof(short) << " - " << typeid(short).name() << endl; cout << "int: " << sizeof(int) << " - " << typeid(int).name() << endl; cout << "long: " << sizeof(long) << " - " << typeid(long).name() << endl; cout << "long long: " << sizeof(long long) << " - " << typeid(long long).name() << endl; 39 / 85

40 typedef SignedEquals<1>::Type s1; typedef SignedEquals<2>::Type s2; typedef SignedEquals<4>::Type s4; typedef SignedEquals<8>::Type s8; cout<< "s1: " << sizeof(s1) << " - " << typeid(s1).name(); cout<< "s2: " << sizeof(s2) << " - " << typeid(s2).name(); cout<< "s4: " << sizeof(s4) << " - " << typeid(s4).name(); cout<< "s8: " << sizeof(s8) << " - " << typeid(s8).name(); 40 / 85

41 => (z.b. RTTI Namen sind nicht genormt) signed char: 1 - signed char short: 2 - short int: 4 - int long: 4 - long long long: 8 - int64 s1: 1 - signed char s2: 2 - short s4: 4 - int s8: 8 - int / 85

42 Unser Ziel ist also ein Typ "SignedEquals<Bits>" "typedef SignedEquals<1>::Type s1; Der exakt soviel Bytes hat wie als Parameter angegeben Als erstes brauchen wir also eine Liste der verfügbaren Signed-Typen Klingt nach einem Typ-Array Und da wir 5 Signed-Typen haben, benötigen wir ein Typ-Array, was mindestens 5 Typen aufnehmen kann Was für ein Zufall -unser Typ-Array kann 5 Typen Hinweis: die Typen müssen ihrer Größe nach angeben werden Man könnte sie auch selber sortieren - aber das sprengt hier unseren Rahmen 42 / 85

43 typedef TypeArray<signed char, short, int, long, long long> SignedTypes; 43 / 85

44 Und jetzt müssen wir nur von vorne nach hinten über das Typ- Array laufen und schauen welcher Typ exakt paßt Laufen von vorne nach hinten => Rekursion mit GetHead und GetTail Passender Typ => TypeIf 44 / 85

45 template<class T, size_t Bytes> struct FindEquals { typedef typename GetHead<T>::Type Head; typedef typename GetTail<T>::Type Tail; static const bool equals = sizeof(head) == Bytes; }; typedef typename TypeIf<equals, Head, typename FindEquals<Tail, Bytes>::Type>::Type Type; template<size_t Bytes> struct FindEquals <TypeArray<Empty, Empty, Empty, Empty, Empty>, Bytes> { typedef void Type; }; 45 / 85

46 Und damit es etwas einfacher zu nutzen ist Typ "SignedEquals" Verbindet die Signed-Typen im Typ-Array mit der Suche " FindEquals Eigentlich eine Aufgabe für C++11 Type-Aliase Die neue C++11 Form von Typedefs Aber ich wollte hier noch C++03 unterstützen Das Idiom hier nennt man auch Type-Generator Template-Typedef template<size_t Bytes> struct SignedEquals : FindEquals<SignedTypes, Bytes> { }; 46 / 85

47 Fertig :-) 47 / 85

48 Aber lassen Sie uns das Beispiel etwas praxis-gerechter machen Wir geben die Byte-Zahl an, die wir mindestens brauchen Fast die gleiche Lösung, nur unsere Bedinung im TypeIf wird anders 48 / 85

49 template<class T, size_t Bytes> struct FindAtLeast { typedef typename GetHead<T>::Type Head; typedef typename GetTail<T>::Type Tail; static const bool enough = sizeof(head) >= Bytes; }; typedef typename TypeIf<enough, Head, typename FindAtLeast<Tail, Bytes>::Type>::Type Type; template<size_t Bytes> struct FindAtLeast <TypeArray<Empty, Empty, Empty, Empty, Empty>, Bytes> { typedef void Type; }; 49 / 85

50 typedef SignedAtLeast<1>::Type s1; typedef SignedAtLeast<2>::Type s2; typedef SignedAtLeast<3>::Type s3; typedef SignedAtLeast<4>::Type s4; typedef SignedAtLeast<5>::Type s5; typedef SignedAtLeast<6>::Type s6; typedef SignedAtLeast<8>::Type s8; cout << "s1: " << sizeof(s1) << " - " << typeid(s1).name(); cout << "s2: " << sizeof(s2) << " - " << typeid(s2).name(); cout << "s3: " << sizeof(s3) << " - " << typeid(s3).name(); cout << "s4: " << sizeof(s4) << " - " << typeid(s4).name(); cout << "s5: " << sizeof(s5) << " - " << typeid(s5).name(); cout << "s6: " << sizeof(s6) << " - " << typeid(s6).name(); cout << "s8: " << sizeof(s8) << " - " << typeid(s8).name(); 50 / 85

51 => (z.b. RTTI Namen sind nicht genormt) s1: 1 - signed char s2: 2 - short s3: 4 - int s4: 4 - int s5: 8 - int64 s6: 8 - int64 s8: 8 - int / 85

52 Was würde man im echten Leben noch ergänzen? Umschreiben auf Bit-Größe Wirklich Plattform-Unabhängig Fehler-Behandlung Was wenn es keinen passenden Typen gibt? Unsigned-Typen integrieren Grenzen statt Größen angeben Angabe von gefordertem Min und Max Wert Klasse BigInt für noch größere Zahlen integrieren 52 / 85

53 Funktions-Existenz 53 / 85

54 Probleme: Man muß eine Funktion aufrufen, wenn sie da ist Wenn nicht, dann nicht aufrufen Beispiele: 2-stufige Konstruktion mit zusätzlichem "init()" After- und Before-Methoden Invarianten-Tests Wie schreibt man generischen Code? Oder es gibt mehrere mögliche Funktionen Gibt es eine spezielle, dann nimmt man die Ansonsten die allgemeine Beispiel: Im Vektor sucht man mit dem Algorithmus "find" Der funktioniert zwar auch beim Set, aber dort nimmt man besser die Element-Funktion "find" des "Sets Schwierig, eine allgemein beste Lösung zu schreiben 54 / 85

55 Also: wie erkenne ich, ob eine Funktion da ist Der Rest - unterschiedliches Verhalten - sollte dann einfach sein Z.B. Verhalten in einen Typ legen und TypeIf nutzen Geht auch anders (besser), aber sprengt wieder unseren Rahmen Lösung: SFINAE und Meta-Programmierung 55 / 85

56 SFINAE Substitution Failure is not an Error Instanziierung von Klassen-Templates Generierung Aller Member-Signaturen auf Klassen-Level Aller zwingend benötigten Funktions-Rümpfe Ist bei den Member-Signaturen ein Fehler, und wird dieser Member nicht zwingend benötigt so wird er aus der Menge der möglicherweise zu nutzenden Member rausgenommen 56 / 85

57 template<typename T> struct HasInitFct { typedef char Yes[1]; typedef char No[2]; template<typename U, U> struct SignatureCheck; template<typename V> static Yes& check(signaturecheck<void(t::*)(), &V::init>*); template<typename> static No& check(...); }; static bool const result = (sizeof(check<t>(0)) == 1); 57 / 85

58 Hinweise Das Ergebnis findet sich in der Variable result Für die Unterscheidung werden die Aufrufe der überladenen Funktion check genommen Damit klar ist, welche Funktion genommen wird, wird die Rückgabe eindeutig unterscheidbar gemacht. Yes ist genau 1 Byte groß No ist genau 2 Byte groß Da Funktionen keine Arrays zurückgeben können, werden Referenzen zurückgegeben Die Ellipse paßt auf jeden Zeiger, aber der konkrete Zeiger in der Yes-Check Funktion paßt prinzipiell besser Hat der Typ T keine passende Funktion, so ist die Yes-Funktions-Signatur ungültig SFINAE wird ausgeschlossen 58 / 85

59 struct NoInit { }; struct WithInit { void init() {} }; 59 / 85

60 cout << boolalpha; cout << "NoInit -> " << HasInitFct<NoInit>::result; cout << "WithInit -> " << HasInitFct<WithInit>::result; => NoInit -> false WithInit -> true 60 / 85

61 Problem Funktioniert nicht mit Vererbung 61 / 85

62 struct NoInit { }; struct WithInit { void init() {} }; struct InheritedInit : WithInit { }; struct DoubleInheritedInit : InheritedInit { }; 62 / 85

63 cout << boolalpha; cout << "NoInit -> " << HasInitFct<NoInit>::result; cout << "WithInit -> " << HasInitFct<WithInit>::result; cout << " InhInit -> " << HasInitFct<Inhe...Init>::result; cout << "DInhInit -> " << HasInitFct<Doubl...Init>::result; => NoInit -> false WithInit -> true InhInit -> false DInhInit -> false 63 / 85

64 Lösung Eigene lokale Klasse, die von T und einer lokalen Mixin-Klasse erbt Die Mixin-Klasse hat die Funktion => Die lokale Mixed Klasse erbt die Funktion von der Mixin-Klasse Hat aber T die Funktion auch (direkt oder geerbt), dann wird die Funktion zweimal geerbt => Ohne klare Entscheidung für eine der geerbten Funktionen ist das fehlerhaft => SFINAE => Funktion wird ausgeschlossen => Ellipsen-Check Funktion gewinnt Hinweis Yes und No sind hier zwischen den Check-Funktionen getauscht worden 64 / 85

65 template<typename T> struct HasRealInitFct { typedef char Yes[1]; typedef char No[2]; struct Mixin { void init(){} }; struct Mixed : public T, public Mixin {}; template<typename U, U> struct SigCheck; template<typename V> static No& check(sigcheck<void(mixin::*)(), &V::init>*); template<typename> static Yes& check(...); }; static bool const result = (sizeof(check<mixed>(0))==1); 65 / 85

66 cout << boolalpha; cout << "NoInit -> " << HasRealInitFct<NoInit>::result; cout << "WithInit -> " << HasRealInitFct<WithInit>::result; cout << " InhInit -> " << HasRealInitFct<I...Init>::result; cout << "DInhInit -> " << HasRealInitFct<D...Init>::result; => NoInit -> false WithInit -> true InhInit -> true DInhInit -> true 66 / 85

67 Bezogen auf unser Vector/Set Beispiel Ist die Funktion iterator find(const value_type&) vorhanden? Ja => Nimm sie Nein => Nimm Algorithmus 67 / 85

68 template<typename T> struct HasFindFct { typedef char Yes[1]; typedef char No[2]; typedef typename T::value_type val; typedef typename T::iterator iter; 68 / 85

69 struct Mixin { iter find(const val&) {} }; struct Mixed : public T, public Mixin {}; template<typename U, U> struct SigCheck; template<typename V> static No& check (SigCheck<iter(Mixin::*)(const value&), &V::find>*); template<typename> static Yes& check(...); }; static bool const result = (sizeof(check<mixed>(0))==1); 69 / 85

70 struct FindAlgo { template<class T> static bool contains (T& con, const typename T::value_type& value) { auto fit = find(begin(con), end(con), value); return fit!=end(con); } }; 70 / 85

71 struct FindMemberFct { template<class T> static bool contains (T& con, const typename T::value_type& value) { typename T::iterator fit = con.find(value); return fit!=end(con); } }; 71 / 85

72 template<class T> bool contains (T& container, const typename T::value_type& value) { typedef typename TypeIf<HasFindFct<T>::result, FindMemberFct, FindAlgo>::Type Type; return Type::contains(container, value); } 72 / 85

73 Fazit 73 / 85

74 TMP ist fast wie normales Programmieren, nur Objekte => Typen Funktionen => Klassen Überladen => Partielle Spezialisierung Return => Public static Typen oder Werte Funktoren => Template-Template-Parameter Lokale Variablen => Private Typen oder Werte Schleifen => Rekursion mit Stopp durch Spezialisierung Kontrollstrukturen => Partielle Spezialisierungen Fehlerhandling => Extra Error-Template-Parameter Compiler-Fehler 74 / 85

75 Und in der Realität muß man sich die Infrastruktur nicht selber schreiben Vieles gibt es schon fertig, z.b. Boost Enable-If Boost MPL Boost Proto Boost Function-Types Boost Fusion 75 / 85

76 TMP wird zur Compile-Zeit ausgeführt Daher wir können nur Dinge durch TMP verbessern, die zur Compile-Zeit schon festlegen Dafür ist hier der ideale Zeitpunkt, um Performance zu gewinnen Wenn Dinge erst zur Laufzeit feststehen, dann ist TMP eher selten hilfreich 76 / 85

77 Was kann man denn zur Compile-Zeit schon machen? (1) Vorberechnung von Werten Z.B. Sin-, Cos-, Fak-Tabellen Wahl des richtigen Typen Siehe SignedAtLeast Beispiel Algorithmen-Anpassungen an den Typen Memcpy statt Operator = bei PODs Kopie- oder Referenz-Übergaben (bzw. Rückgaben) Algorithmen-Auswahl anhand von Typen (Iterator-Kategorien) Größen (Sort-Algorithmus bei Arrays fester Größe) Ausrollen von Schleifen Z.B. beim Setzen von Containern oder anderen Mengen 77 / 85

78 Was kann man denn zur Compile-Zeit schon machen? (2) Ablauf-Änderungen in Abhängigkeit von Member-Existenz Siehe Beispiel Funktions-Existenz Domain Specific Embeded Languages (DSELs) Sub-Sprache eingebettet in C++ für speziellen Fach-Probleme Expression-Templates Boost.Spirit Boost.Expressive Anpassungen von Plattform-Spezifika Typ-Abhängiges Verhalten Traits DB-Schnittstellen Config-API Numeric-Limits 78 / 85

79 Denken Sie bei Problemen (Herausforderungen) immer darüber nach Sind alle Parameter schon zur Compile-Zeit bekannt Dann müßte das Problem doch mit TMP lösbar sein Immer wenn Sie programmieren: Dann geschieht das zur Compile-Zeit Treffen Sie Entscheidungen, die der Compiler für Sie treffen könnte? Treffen sollte? Da er mehr weiss, und nichts vergißt? 79 / 85

80 Literatur 80 / 85

81 C++ Templates Nicolai M. Josuttis David Vandevoorde Addison-Wesley Longman ISBN-13: / 85

82 Modern C++ Design Andrei Alexandrescu Addison-Wesley Longman mitp ISBN-13: / 85

83 Advanced C++ Metaprogramming Davide Di Gennaro CreateSpace Independent Publishing Platform ISBN-13: / 85

84 C++ Template Metaprogramming David Abrahams Aleksey Gurtovoy Addison-Wesley Longman ISBN-13: / 85

85 Fragen? 85 / 85