Metaprogrammierung in C ++ und in D

Die zwei größten Dinge, die helfen, template metaprogramming in D sind template-Einschränkungen und static if - beide C++ könnte theoretisch hinzufügen und die profitieren würden ihn sehr.

Vorlage Einschränkungen ermöglichen es Ihnen, eine Bedingung für eine Vorlage, die wahr sein muss, für die Vorlage zu können instanziiert werden. Dies ist beispielsweise die Unterschrift eines std.algorithm.find's überlastungen:

R find(alias pred = "a == b", R, E)(R haystack, E needle)
    if (isInputRange!R &&
        is(typeof(binaryFun!pred(haystack.front, needle)) : bool))

Damit diese Vorlagen-Funktion in der Lage sein, die instanziiert werden sollen, die Art R muss ein Eingabebereich definiert durch std.range.isInputRange (so isInputRange!R muss true), und das angegebene Prädikat muss eine binäre Funktion, die kompiliert und mit der angegebenen Argumente und gibt eine Art, die implizit konvertierbar bool. Wenn das Ergebnis der Bedingung in der Vorlage Einschränkung ist falsedann die Vorlage nicht kompilieren. Dadurch wird nicht nur schützen Sie aus dem fiesen Vorlage Fehler, die Sie in C++ als templates wird nicht kompiliert, mit Ihren jeweiligen Argumenten, aber es macht es so, dass Sie überlastet werden kann-Vorlagen auf Basis Ihrer Vorlage-Einschränkungen. Zum Beispiel gibt es eine weitere überladung von find die

R1 find(alias pred = "a == b", R1, R2)(R1 haystack, R2 needle)
if (isForwardRange!R1 && isForwardRange!R2
        && is(typeof(binaryFun!pred(haystack.front, needle.front)) : bool)
        && !isRandomAccessRange!R1)

Dauert es exakt die gleichen Argumente, aber seine Einschränkung ist anders. So werden verschiedene Arten der Arbeit mit verschiedenen überladungen der gleichen Vorlagen-Funktion, und die beste Umsetzung von find kann verwendet werden, für jeden Typ. Es gibt keine Möglichkeit, das zu tun diese Art der Sache sauber in C++. Mit ein wenig Vertrautheit mit den Funktionen und Vorlagen, die Sie in Ihrem typischen Vorlage Einschränkung, Vorlage Einschränkungen in D sind relativ leicht zu Lesen, während Sie brauchen etwas sehr kompliziertes template metaprogramming in C++, sogar zu versuchen, so etwas wie dieses, die Ihre durchschnittlichen Programmierer ist nicht in der Lage sein zu verstehen, geschweige denn tatsächlich auf eigene Faust tun. Boost ist ein Paradebeispiel dafür. Es hat einige tolle Sachen, aber es ist unglaublich kompliziert.

static if verbessert sich die situation noch weiter. Genau wie mit der Vorlage Einschränkungen, jede Bedingung, die ausgewertet werden können, zur compile-Zeit verwendet werden kann. z.B.

static if(isIntegral!T)
{
    //...
}
else static if(isFloatingPoint!T)
{
    //...
}
else static if(isSomeString!T)
{
    //...
}
else static if(isDynamicArray!T)
{
    //...
}
else
{
    //...
}

Welche Filiale ist zusammengestellt hängt davon ab, welche Bedingung zuerst ausgewertet wird true. Also innerhalb einer Vorlage können Sie sich spezialisieren-Stücke seiner Umsetzung auf der Grundlage der Arten, dass die Vorlage instanziiert wurde oder basiert die auf etwas, die ausgewertet werden können, zur compile-Zeit. Zum Beispiel core.time verwendet

static if(is(typeof(clock_gettime)))

um code zu kompilieren, anders abhängig, ob das system bietet clock_gettime oder nicht (wenn clock_gettime da ist, er es verwendet, ansonsten benutzt es gettimeofday).

Wahrscheinlich die krassen Beispiel, dass ich gesehen habe, wo D verbessert die Vorlagen mit einem problem, das mein team bei der Arbeit lief in in C++. Mussten wir instanziieren die Vorlage unterschiedlich basierend auf, ob der Typ es gegeben wurde, abgeleitet von einer bestimmten Basisklasse oder nicht. Wir landeten mit einer Lösung auf Basis dieser stack overflow Frage. Es funktioniert, aber es ist ziemlich kompliziert, nur für die Prüfung, ob eine Art von einer anderen abgeleitet ist.

In D, aber alles, was Sie tun müssen ist, verwenden Sie die : Betreiber. z.B.

auto func(T : U)(T val) {...}

Wenn T implizit konvertierbar U (wie wäre es, wenn T wurden, stammen aus U), dann func kompiliert wird, in der Erwägung, dass, wenn T ist nicht implizit konvertierbar Udann wird es nicht. Dass einfache Verbesserung macht auch basic template Spezialisierungen viel mächtiger (auch ohne Vorlage Einschränkungen oder static if).

Persönlich verwende ich selten templates in C++, anders als bei Containern und die gelegentliche Funktion, die in <algorithm>weil Sie so viel von einem Schmerz zu verwenden. Sie führen zu hässlichen Fehlern und sind sehr schwer zu tun, nichts mit Phantasie. Zu tun, was auch ein wenig kompliziert, Sie müssen sehr geschickt im Umgang mit templates und template-metaprogramming. Mit Vorlagen in D obwohl, es ist so einfach, dass ich Sie alle die Zeit nutzen. Die Fehler sind viel leichter zu verstehen und zu behandeln (aber Sie sind noch schlimmer als Fehler sind in der Regel mit nicht-Vorlagen-Funktionen), und ich don ' T haben, um herauszufinden, wie die Kraft der Sprache zu tun, was ich will, mit ausgefallenen metaprogramming.

Gibt es keinen Grund, dass C++ nicht gewinnen viel von diesen Fähigkeiten, dass D (C++ - Konzepte helfen würde, wenn Sie jemals diese aussortiert), aber wenn Sie fügen einfache bedingte Kompilierung mit Konstrukten, ähnlich wie Vorlage Einschränkungen und static if C++, C++ - templates einfach nicht zu vergleichen mit D-Vorlagen in Bezug auf Benutzerfreundlichkeit und Leistung.

InformationsquelleAutor der Antwort Jonathan M Davis

Die besten Beispiele D metaprogramming sind D-standard-library-Module, die machen starken Gebrauch von es vs. C++ Boost und STL-Module. Check-out D std.Angebotstd.Algorithmusstd.funktionale und std.Parallelität. Keiner von diesen wäre einfach zu implementieren in C++, zumindest mit der Art der sauberen, ausdrucksstarken API, die die D-Module haben.

Der beste Weg, um zu lernen, D metaprogramming, IMHO, ist von dieser Art von Beispielen. Ich lernte weitgehend durch das Lesen der code auf std.Algorithmus und std.Bereich, die geschrieben wurden von Andrei Alexandrescu (eine C++ template metaprogramming-guru, hat sich intensiv mit D). Dann habe ich das, was ich gelernt und dazu beigetragen, die std.Parallelität Modul.

Beachten Sie auch, dass D hat compile-Zeit-Funktion Auswertung (CTFE), die ähnlich zu C++1x s constexpr sondern viel mehr im Allgemeinen, dass eine große und wachsende Teilmenge der Funktionen, die ausgewertet werden können zur Laufzeit ausgewertet werden kann, unverändert zur compile-Zeit. Dies ist nützlich für die compile-time code generation und der generierte code kompiliert werden kann mit string Mixins in Verbindung.

InformationsquelleAutor der Antwort dsimcha

Hier ist ein Stück von D-code eine benutzerdefinierte-gemacht map() die gibt die Ergebnisse von Referenz -.

Es erstellt zwei arrays der Länge 4, Karten jedes entsprechende paar von Elementen das element mit dem minimalen Wert, und multipliziert es mit 50, und speichert das Ergebnis wieder in das ursprüngliche array.

Einige wichtige Merkmale zu beachten sind die folgenden:

• Die Vorlagen sind variadic: map() könnte eine beliebige Anzahl von Argumenten.

• Den code ist (relativ) kurze! Die Mapper Struktur, die die core-Logik, ist nur 15 Zeilen -- und doch, es kann so viel mit so wenig. Mein Punkt ist nicht, dass dies unmöglich ist in C++, aber das ist sicherlich nicht so kompakt und sauber.

import std.metastrings, std.typetuple, std.range, std.stdio;

void main() {
    auto arr1 = [1, 10, 5, 6], arr2 = [3, 9, 80, 4];

    foreach (ref m; map!min(arr1, arr2)[1 .. 3])
        m *= 50;

    writeln(arr1, arr2); //Voila! You get:  [1, 10, 250, 6][3, 450, 80, 4]
}

auto ref min(T...)(ref T values) {
    auto p = &values[0];
    foreach (i, v; values)
        if (v < *p)
            p = &values[i];
    return *p;
}

Mapper!(F, T) map(alias F, T...)(T args) { return Mapper!(F, T)(args); }

struct Mapper(alias F, T...) {
    T src;  //It's a tuple!

    @property bool empty() { return src[0].empty; }

    @property auto ref front() {
        immutable sources = FormatIota!(q{src[%s].front}, T.length);
        return mixin(Format!(q{F(%s)}, sources));
    }

    void popFront() { foreach (i, x; src) { src[i].popFront(); } }

    auto opSlice(size_t a, size_t b) {
        immutable sliced = FormatIota!(q{src[%s][a .. b]}, T.length);
        return mixin(Format!(q{map!F(%s)}, sliced));
    }
}


//All this does is go through the numbers [0, len),
//and return string 'f' formatted with each integer, all joined with commas
template FormatIota(string f, int len, int i = 0) {
    static if (i + 1 < len)
        enum FormatIota = Format!(f, i) ~ ", " ~ FormatIota!(f, len, i + 1);
    else
        enum FormatIota = Format!(f, i);
}

InformationsquelleAutor der Antwort Mehrdad

String-manipulation, auch string-parsing.

Dies ist ein MP-Bibliothek generiert recursive decent Parser basiert auf Grammatiken definiert, die in strings mit (mehr oder weniger) BNF. Ich habe nicht berührt es, in Jahren, aber es verwendet, um zu arbeiten.

InformationsquelleAutor der Antwort BCS

Nur gegen die D, ray-tracing-post, hier ist eine C++ compile time ray tracer (metatrace):

(by the way, verwendet es meist C++2003 metaprogramming; es wäre besser lesbar mit der neuen constexprs)

InformationsquelleAutor der Antwort Sebastian Mach