Wie ist std::tuple umgesetzt?

Ich würde gerne wissen, wie sind Tupel implementiert in der standard-Bibliothek für C++0x. Ich versuchte zu Lesen Beschreibung in libstdc++ - Handbuch und dann Lesen Vorlage Auflistung, aber es ist wirklich schwer zu verstehen, wie es funktioniert, vor allem beim Lesen von code.

Kann jemand erklären mir in wenigen Sätzen die Idee von tuple-Implementierung? Ich möchte dies wissen, weil ich denken über die Verwendung von Tupeln in meinem code und ich möchte verstehen, wie es funktioniert und welche Art von overhead bedeutet es bringt (erstreckt sich kompilieren nur Zeit, führen viele copy-Operationen auf den Speicher, ausführen viele andere Funktion im Konstruktor, etc).

InformationsquelleAutor Goofy | 2010-10-28
  1. 26

    Ist ein Ansatz zur Implementierung von Tupeln mit mehrfach-Vererbung. Der Tupel-Elemente werden gehalten von leaf-Klassen, und die tuple-Klasse selbst erbt von mehreren Blättern. In pseudo-code:

    template<typename T0, typename T1, ..., typename Tn>
class PseudoTuple : TupleLeaf<0, T0>, TupleLeaf<1, T1>, ..., TupleLeaf<n, Tn> {
   ...
};

    Jedes Blatt hat einen index, so dass jeder Basis-Klasse wird einzigartig, auch wenn die Typen, die Sie enthalten, identisch sind, so können wir auf die N-TEN element mit einem einfachen static_cast:

    static_cast<TupleLeaf<0, T0>*>(this);
//...
static_cast<TupleLeaf<n, Tn>*>(this);

    Habe ich geschrieben, eine detaillierte Erklärung zu diesem "flachen" Tupel Umsetzung hier: C++11-tuple-Implementierung-details (Teil 1)

    • Ja das ist eine Super Erklärung ! Das ist leider nicht, wie das Tupel wird umgesetzt in die libstdc++, die man sich auf die rekursive Implementierung. Kann nicht warten, für eine weit verbreitet libc++ !
    • Es könnte nützlich sein, kurz zu beschreiben die nicht-rekursive Implementierung zu.
    • erm, das ist die nicht-rekursive Implementierung (T : L1, L2, L3 vs T : L1 : L2 : L3 des rekursiven Implementierung)
    • Sorry, ich meinte die rekursive Implementierung.
    • Konnte Sie auch kurz auf die vor-und Nachteile der rekursiven und nicht-rekursiven Implementierung?
    InformationsquelleAutor mitchnull
  2. 10

    Einem Tupel wird in der Regel umgesetzt werden, da eine compile-Zeit verkettete Liste.

    Der code ist ein wenig verschleiert durch die template-syntax, aber folgende Elemente sind normalerweise vorhanden:

    1. eine Kette von Klassen mit head-und tail-Elemente (cons-Elemente)
    2. einen leeren Schwanz Instanz an das Ende der Liste.
    3. rekursiven code zum Durchlaufen der Liste an einem bestimmten index, umgesetzt als rekursive template-Instanziierungen (instanziiert zur compile-Zeit).

    Gibt es vernünftige Implementierungen in C++03 (z.B. boost).

    Variadic-templates ermöglichen es, eine unbegrenzte Anzahl von Elementen, wie erwähnt von Motti.

    Den Kosten ist in der Regel eine compile-Zeit-ein. Copy-Konstruktoren aufgerufen werden könnten, die während der Initialisierung (max 1), und beim kopieren der Tupel selbst.

    InformationsquelleAutor mirk
  3. 6

    Ich dachte, ich möchte hinzufügen, ein nicht-pseudocode einfache rekursive Implementierung zur Referenz

    #include <iostream>

//Contains the actual value for one item in the tuple. The 
//template parameter `i` allows the
//`Get` function to find the value in O(1) time
template<std::size_t i, typename Item>
struct TupleLeaf {
    Item value;
};

//TupleImpl is a proxy for the final class that has an extra 
//template parameter `i`.
template<std::size_t i, typename... Items>
struct TupleImpl;

//Base case: empty tuple
template<std::size_t i>
struct TupleImpl<i>{};

//Recursive specialization
template<std::size_t i, typename HeadItem, typename... TailItems>
struct TupleImpl<i, HeadItem, TailItems...> :
    public TupleLeaf<i, HeadItem>, //This adds a `value` member of type HeadItem
    public TupleImpl<i + 1, TailItems...> //This recurses
    {};

//Obtain a reference to i-th item in a tuple
template<std::size_t i, typename HeadItem, typename... TailItems>
HeadItem& Get(TupleImpl<i, HeadItem, TailItems...>& tuple) {
    //Fully qualified name for the member, to find the right one 
    //(they are all called `value`).
    return tuple.TupleLeaf<i, HeadItem>::value;
}

//Templated alias to avoid having to specify `i = 0`
template<typename... Items>
using Tuple = TupleImpl<0, Items...>;

int main(int argc, char** argv) {
    Tuple<int, float, std::string> tuple;
    Get<0>(tuple) = 5;
    Get<1>(tuple) = 8.3;
    Get<2>(tuple) = "Foo";
    std::cout << Get<0>(tuple) << std::endl;
    std::cout << Get<1>(tuple) << std::endl;
    std::cout << Get<2>(tuple) << std::endl;
    return 0;
}
    • just for the record: dies ist eine rekursive Implementierung, nicht eine Wohnung ein, wie ich beschrieben 🙂
    • Entschuldigung, ich habe deine Antwort missverstanden. Ich bearbeitete mine zu entfernen, die behaupten, dass es implementiert Ihre Lösung.
    InformationsquelleAutor Andrea Allais
  4. 3

    Umsetzung std::tuple ist möglich über variadic templates, eingeführt wurden in der core-Sprache.

    Ich weiß, das wirft die Frage auf, aber es gibt Ihnen eine bessere search phrase Forschung.

    • Plus, die Umsetzung ist nicht trivial, wie durch die Tatsache belegt, dass OP erwähnt, versuchte zu verstehen, es durch das Lesen der code einer Beispiel-Implementierung.
    • Diese Antwort wird diskutiert, auf meta.
    • das OP liest den code im Jahr 2010, als variadic templates waren noch nicht allgemein verstanden. Ich gab ihm die Werkzeuge, um zu verstehen, variadic-Vorlagen. Ich halte das für eine Antwort sein.
    InformationsquelleAutor Motti
Schreibe einen Kommentar