Hilfe mit Typ-Traits

Question

Angenommen, wir haben die folgende Template-Klasse

template<typename T> class Wrap { /* ... */ }; 

Wir nichtWrap ändern können. Es ist wichtig.

Es gibt Klassen, die von Wrap<T> abgeleitet sind. Zum Beispiel

class NewInt : public Wrap<int>  { /* ... */ }; 
class MyClass : public Wrap<myclass> { /* ... */ }; 
class Foo  : public Wrap<Bar>  { /* ... */ }; 

Wir nicht diese Klassen ändern. Alle oben genannten Klassen sind Drittanbieter. Das sind nicht meine.

Ich brauche die folgenden Kompilierung type_traits:

template<class T> 
struct is_derived_from_Wrap { 
    static const bool value = /* */; 
}; 

Was brauche ich?

assert(is_derived_from_Wrap<Int>::value == true); // Indeed I need static assert 
assert(is_derived_from_Wrap<MyClass>::value == true); 
assert(is_derived_from_Wrap<char>::value == false); 
struct X {}; 
assert(is_derived_from_Wrap<X>::value == false); 

Answer 1

Sie können dies mit SFINAE tun, aber seine Art magische wenn Sie nicht wissen, was los ist ...

template<typename T> class Wrap { }; 

struct myclass {}; 
struct X {}; 

class Int  : public Wrap<int>  { /* ... */ }; 
class MyClass : public Wrap<myclass> { /* ... */ }; 

template< typename X > 
struct is_derived_from_Wrap 
{ 
    struct true_type { char _[1]; }; 
    struct false_type { char _[2]; }; 

    template< typename U > 
    static true_type test_sfinae(Wrap<U> * w); 
    static false_type test_sfinae(...); 

    enum { value = sizeof(test_sfinae((X*)(0)))==sizeof(true_type) }; 
}; 


#include <iostream> 
#define test(X,Y) std::cout<<(#X " == " #Y)<<" : "<<((X)?"true":"false") <<std::endl; 

int main() 
{ 
    test(is_derived_from_Wrap <Int>::value, true); 
    test(is_derived_from_Wrap <MyClass>::value, true); 
    test(is_derived_from_Wrap <char>::value, false); 
    test(is_derived_from_Wrap <X>::value, false); 
} 

Das die erwartete Ausgabe

is_derived_from_Wrap <Int>::value == true : true 
is_derived_from_Wrap <MyClass>::value == true : true 
is_derived_from_Wrap <char>::value == false : false 
is_derived_from_Wrap <X>::value == false : false 

Es gibt ein paar Fallstricke gibt mit meinem Code. Es wird auch true zurückgegeben, wenn der Typ ein Umbruch ist.

Dies kann wahrscheinlich mit etwas mehr SFINAE Magie behoben werden, wenn nötig.

Es wird falsch zurück, wenn die Ableitung noch keine öffentliche Ableitung (das heißt ist privat oder geschützt)

struct Evil : private Wrap<T> { }; 
assert(is_derived_from_Wrap<Evil>::value == 0); 

Ich vermute, das nicht behoben werden kann. (Aber ich kann falsch liegen). Aber ich vermute, öffentliche Vererbung ist genug.

Answer 2

Im Folgenden legt fest, ob etwas ist ein Wrap:

template<class T> 
struct is_Wrap { static const bool value = false; }; 

template<typename T> 
struct is_Wrap< Wrap<T> > { static const bool value = true; }; 

Da Ableitung ist eine Is-A-Beziehung, alles abgeleitet von Wrap<T> ist auch ein Wrap<T> und sollte durch diese gefunden werden.

Answer 3

Sie müssen einige ziemlich involvierte Template-Metaprogrammierung durchführen, um zu bestimmen, ob eine Klasse X von einem anderen Y abgeleitet ist, im allgemeinen Fall. Grundsätzlich X leitet sich von Y, wenn:

1. Y implizit in X umgewandelt werden
2. X und Y sind nicht vom gleichen Typ

Andrei Alexandrescu erklärt, wie dies zu tun (zusammen mit vielen anderen Template-Tricks) in seinem Buch "Modern C++ Design".

Sie können Code finden, der Ihr Problem entweder in der Loki Bibliothek oder der uSTL Implementierung löst, beide von Alexandrescu geschrieben.