C++ statische Polymorphie (CRTP) und die Verwendung von typedefs von abgeleiteten Klassen

Lese ich die Wikipedia-Artikel über den neugierig-recurring template pattern in C++ tut für statische (read: compile-Zeit) - Polymorphismus. Ich wollte zu verallgemeinern, so dass ich ändern könnte, die Rückgabetypen der Funktionen, basierend auf den abgeleiteten Typ. (Dies scheint, wie es sollte möglich sein, da die base-Typ kennt die abgeleitete Typ von der template-parameter). Leider ist der folgende code wird nicht kompiliert mit MSVC 2010 (ich weiß nicht, haben Sie einfachen Zugang zu gcc jetzt, so dass ich habe nicht versucht es noch). Wer weiß, warum?

template <typename derived_t>
class base {
public:
    typedef typename derived_t::value_type value_type;
    value_type foo() {
        return static_cast<derived_t*>(this)->foo();
    }
};

template <typename T>
class derived : public base<derived<T> > {
public:
    typedef T value_type;
    value_type foo() {
        return T(); //return some T object (assumes T is default constructable)
    }
};

int main() {
    derived<int> a;
}

BTW, ich habe einen work-around mit extra-template-Parameter, aber ich weiß nicht wie es---es wird sehr ausführlich bei der übergabe viele Arten die Vererbungskette.

template <typename derived_t, typename value_type>
class base { ... };

template <typename T>
class derived : public base<derived<T>,T> { ... };

EDIT:

Die Fehlermeldung, dass MSVC 2010 gibt in dieser situation ist error C2039: 'value_type' : is not a member of 'derived<T>'

g++ 4.1.2 (via codepad.org) sagt error: no type named 'value_type' in 'class derived<int>'

  • Nur damit Sie wissen, codepad.org kompilieren und ausführen von code für Sie, und ich glaube, es verwendet den gcc/g++. So sind Sie nie außerhalb der Reichweite von g++ 🙂
  • könntest du welche Fehler sind Sie immer so, dass ich nützlich sein für die Leser.
  • Ideone verwendet gcc sicher, es ist also noch einer 🙂
  • vielen Dank für den Tipp über codepad.org! @Sriram: Guter Anruf. Ich fügte Sie.
InformationsquelleAutor Samuel Powell | 2011-05-15
  1. 59

    derived ist unvollständig, wenn Sie verwenden es als ein template-argument zu base in seiner Basisklassen-Liste.

    Einer gemeinsamen Lösung ist die Verwendung einer traits-Klasse-Vorlage. Hier ist dein Beispiel, traitsified. Dies zeigt, wie beide Arten und Funktionen von der abgeleiteten Klasse durch die Züge.

    //Declare a base_traits traits class template:
template <typename derived_t> 
struct base_traits;

//Define the base class that uses the traits:
template <typename derived_t> 
struct base { 
    typedef typename base_traits<derived_t>::value_type value_type;
    value_type base_foo() {
        return base_traits<derived_t>::call_foo(static_cast<derived_t*>(this));
    }
};

//Define the derived class; it can use the traits too:
template <typename T>
struct derived : base<derived<T> > { 
    typedef typename base_traits<derived>::value_type value_type;

    value_type derived_foo() { 
        return value_type(); 
    }
};

//Declare and define a base_traits specialization for derived:
template <typename T> 
struct base_traits<derived<T> > {
    typedef T value_type;

    static value_type call_foo(derived<T>* x) { 
        return x->derived_foo(); 
    }
};

    Brauchen Sie nur, um sich zu spezialisieren base_traits für alle Typen, die Sie für die Vorlage verwenden-argument derived_t von base und stellen Sie sicher, dass jede Spezialisierung bietet allen Mitgliedern, die base erfordert.

    • Ich erstellte eine test-Datei und kompilierten code des OP mit setzen Sie eine main() mit Ubuntu-g++ 4.4.1 funktioniert Es einwandfrei. Deklarieren eines Objekts wie Derived<int> Fehler gibt, ich bin versucht, herauszufinden, warum ?
    • Das ist, weil in einem leeren main() keine template-Instanziierung stattfindet. Bestimmte Fehler nur kommen, wenn der compiler versucht zu instanziieren und zu verwenden die Vorlage.
    • Richtig, Sie haben zu instanziieren die Vorlage, denn es werden alle Fehler hier; wenn Sie hinzufügen int main() { derived<int>().base_foo(); } auf der Unterseite meines Merkmale Beispiel (dies zwingt die Instanziierung von allem), sollte es kompilieren mit Visual C++ 2010, g++ 4.5.1, und die aktuelle Clang baut.
    • vereinbart. Allerdings würde ich lieber wechseln, die Argumente und machen derived ein Standard-argument (dieser Ansatz wird nicht verlangen viel code). Ich habe geschrieben in meiner Antwort.
    • könnten Sie erklären, mehr über das, was Sie bedeuten, von diesem "abgeleitet ist unvollständig, wenn Sie verwenden es als ein template-argument zu base in seine base classes-Liste". was Weg ist, ist es unvollständig?
    • und Sriram, ich spüre eine Verwechslung möglich ist. Leicht reduzierte version mit abgeleiteter nicht-Vorlage: struct derived : base<derived> {...}; macht die base_traits nicht definiert.

    InformationsquelleAutor James McNellis
  2. 8

    Einem kleinen Nachteil der Verwendung von Eigenschaften ist, dass Sie haben zu erklären, eine für jede abgeleitete Klasse. Schreiben Sie eine weniger ausführliche und redondant workaround so :

    template <template <typename> class Derived, typename T>
class base {
public:
    typedef T value_type;
    value_type foo() {
        return static_cast<Derived<T>*>(this)->foo();
    }
};

template <typename T>
class Derived : public base<Derived, T> {
public:
    typedef T value_type;
    value_type foo() {
        return T(); //return some T object (assumes T is default constructable)
    }
};

int main() {
    Derived<int> a;
}
    • was ist das Merkmal hier?
    • Es gibt keine, das ist der Punkt
    • Das sieht interessant aus, aber ich weiß nicht wirklich verstehen, könnten Sie erklären, es ein bisschen mehr sein?
    • Anstatt sich auf den abgeleiteten Typ zu extrahieren, die value_type in der Basis, die wir direkt weitergeben, um die Basis-Klasse. Die Basisklasse hat nun zwei template-Parameter. Dies ist sehr praktisch, wenn Sie nur eine oder zwei Arten zu gehen, aber wenn Sie haben, das ist nicht bequem.
    • In der Tat, Sie könnte verwenden variadic templates und Tupel für ein bisschen mehr Flexibilität.
    • Es ist nicht überflüssig, da Sie nicht übergeben Sie den Typ der abgeleiteten Klasse, aber seine Vorlage als template-argument der Basisklasse. (Hinweis: ein entfernen können Sie die Typdefinition in der abgeleiteten Klasse)
    • Ja, ich löschte meinen Kommentar, da ich erkannte, das war nicht zu tun, was ich dachte. Und eine Vorlage, in etwa 3 Stunden werde ich haben herausgefunden, was es wird zu tun. 😉

    InformationsquelleAutor matovitch
  3. 6

    In C++14 Sie können die typedef und benutzen Sie die Funktion auto Rückgabetyp Abzug:

    template <typename derived_t>
class base {
public:
    auto foo() {
        return static_cast<derived_t*>(this)->foo();
    }
};

    Dies funktioniert, weil der Abzug der Rückgabetyp base::foo verzögert, bis derived_t abgeschlossen ist.

    • Funktioniert diese Technik, die Grenzen der Rückgabewert? Funktioniert es auf einem Feld oder einer Funktion parameter? Wird C++17 noch mehr helfen?
    InformationsquelleAutor Oktalist
  4. 2

    Alternative zu Typ-Eigenschaften, die erfordert weniger boilerplate wird zum nest Ihrer abgeleiteten Klasse in eine wrapper-Klasse, die hält Ihre Typdefinitionen (oder mit s), und übergeben Sie die wrapper als template-argument zu Ihrer Basisklasse.

    template <typename Outer>
struct base {
    using derived = typename Outer::derived;
    using value_type = typename Outer::value_type;
    value_type base_func(int x) {
        return static_cast<derived *>(this)->derived_func(x); 
    }
};

//outer holds our typedefs, derived does the rest
template <typename T>
struct outer {
    using value_type = T;
    struct derived : public base<outer> { //outer is now complete
        value_type derived_func(int x) { return 5 * x; }
    };
};

//If you want you can give it a better name
template <typename T>
using NicerName = typename outer<T>::derived;

int main() {
    NicerName<long long> obj;
    return obj.base_func(5);
}
    • Clever, aber das hat Nebenwirkungen. Zum Beispiel T werden nicht in der Lage abgeleitet werden, die in der Funktion tamplates, zum Beispiel template<class T> f(outer<T>::derived x) (wie opossed zu template<class T> f(derived2<T> x).
    • Schreiben Sie template <class C, class T = typename C::value_type> auto f(C x). Wenn Sie sind besorgt über die Annahme beliebiger Typen, die Sie hinzufügen können class = std::enable_if_t< std::is_same_v< C, NicerName<T> >, int> zu den template-Parameter-Liste, aber es wird ziemlich lange.
    InformationsquelleAutor Alkis
  5. 0

    Ich weiß, dass dies im Grunde ist die Problemumgehung, die Sie gefunden und weiß nicht wie, aber ich wollte, um es zu dokumentieren und auch zu sagen, dass es im Grunde die aktuelle Lösung für dieses problem.

    Bin ich auf der Suche nach einem Weg, dies zu tun für eine Weile und nie eine gute Lösung gefunden.
    Die Tatsache, dass es nicht möglich ist, ist der Grund, warum letztlich Dinge wie boost::iterator_facade<Self, different_type, value_type, ...> müssen viele Parameter.

    Möchten wir natürlich auch etwas, so etwas wie dies funktioniert:

    template<class CRTP> 
struct incrementable{
    void operator++(){static_cast<CRTP&>(*this).increment();}
    using ptr_type = typename CRTP::value_type*; //doesn't work, A is incomplete
};

template<class T>
struct A : incrementable<A<T>>{
    void increment(){}
    using value_type = T;
    value_type f() const{return value_type{};}
};

int main(){A<double> a; ++a;}

    Wenn dies möglich war, alle Eigenschaften der abgeleiteten Klasse weitergeleitet werden konnten implizit ot der Basisklasse. Die Redewendung fand ich den gleichen Effekt zu erhalten ist das bestehen der Eigenschaften der Basisklasse völlig.

    template<class CRTP, class ValueType> 
struct incrementable{
    void operator++(){static_cast<CRTP&>(*this).increment();}
    using value_type = ValueType;
    using ptr_type = value_type*;
};

template<class T>
struct A : incrementable<A<T>, T>{
    void increment(){}
    typename A::value_type f() const{return typename A::value_type{};}
//   using value_type = typename A::value_type;
//   value_type f() const{return value_type{};}
};

int main(){A<double> a; ++a;}

    https://godbolt.org/z/2G4w7d

    Der Nachteil ist, dass das Merkmal in der abgeleiteten Klasse zugegriffen werden, mit einer qualifizierten typename oder wieder aktiviert von using.

    InformationsquelleAutor alfC
Schreibe einen Kommentar