Wie kann CRTP in C Typedefs aus abgeleiteten Klassen für statischen Polymorphismus verarbeiten?

C Static Polymorphism (CRTP) mit Typedefs aus abgeleiteten Klassen

Beim statischen Polymorphismus, auch bekannt als Polymorphismus zur Kompilierungszeit, werden die Typen von Abgeleitete Klassen sind der Basisklasse zur Kompilierungszeit bekannt. Dies kann mithilfe des neugierig wiederkehrenden Vorlagenmusters (CRTP) erreicht werden. Möglicherweise möchten Sie jedoch die Rückgabetypen von Funktionen basierend auf dem abgeleiteten Typ anpassen.

Bedenken Sie den folgenden Code:

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)
    }
};

Dieser Code kann jedoch aufgrund der Verwendung von möglicherweise nicht kompiliert werden der Typalias value_type aus der abgeleiteten Klasse innerhalb der Basisklassenvorlage. Der Fehler besteht darin, dass „derived“ unvollständig ist, wenn es als Vorlagenargument für die Basis verwendet wird.

Eine Lösung besteht darin, eine Merkmalsklassenvorlage zu verwenden. Hier ist ein modifiziertes Beispiel:

// 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(); 
    }
};

Durch die Spezialisierung von base_traits für jeden abgeleiteten Typ können Sie die erforderlichen Mitglieder (value_type und call_foo) bereitstellen, die für die Basisklassenvorlage erforderlich sind. Dadurch können Sie innerhalb der Basisklassenvorlage auf Typedefs und Funktionen der abgeleiteten Klasse zugreifen und so einen statischen Polymorphismus mit benutzerdefinierten Rückgabetypen erreichen.

Das obige ist der detaillierte Inhalt vonWie kann CRTP in C Typedefs aus abgeleiteten Klassen für statischen Polymorphismus verarbeiten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!