Wie erzwingen Kind-of-X-Beschränkung für Vorlagenparameter?

Question

Angenommen, ich möchte die Einschränkung erzwingen, dass der übergebene Template-Parameter ein Kind von Foo ist.

Gibt es eine Möglichkeit, dies durch Typ-Züge zu erzwingen? Ein Kompilierungsfehler static_assert wäre großartig.

In dem Code unten, machen wir es eine zweiteilige (separate) Frage.

1. Lassen Sie nur My_Limited_Template<Bar> kompilieren.
2. Lassen Sie nur My_Limited_Template<TBar> kompilieren.

EDIT ich für die schlechte Namensgebung entschuldigen: TBar und TBaz sollen Nicht-Template-Klassen auf Zwecke sein. Ich lege T nur vor dem Namen aus den Klassen in Teil eindeutig zu machen 1.

CODE

struct Foo { };    // no 
struct Bar : public Foo { }; // yes 
struct Baz { };    // no 

template< typename T > 
struct TFoo { };      // no 
struct TBar : public TFoo<TBar> { }; // yes 
struct TBaz { };      // no 

template< typename T > 
struct My_Limited_Template 
{ 
    // Part One: 
    // My_Limited_Template<Foo> // disallow 
    // My_Limited_Template<Bar> // allow 
    // My_Limited_Template<Baz> // disallow 
    // 
    // Part Two: 
    // My_Limited_Template<TFoo<int>> // disallow 
    // My_Limited_Template<TBar>  // allow 
    // My_Limited_Template<TBaz>  // disallow 
}; 

Answer 1

Ich gehe davon aus, dass Sie einen Fehler bei der Definition von TBar und TBas gemacht, überprüfen, ob meine Modifikation ist richtig.

#include <type_traits>  

struct Foo { };    // don't allow this 
struct Bar : public Foo { }; // allow this 
struct Baz { };    // don't allow this 

template< typename T > struct TFoo { };      
template< typename T > struct TBar : public TFoo<TBar<T>> { }; 
template< typename T > struct TBaz { };      

template< typename T > 
struct My_Limited_Template 
{ 
     static_assert(
       (std::is_base_of<Foo,T>::value && !std::is_same<T,Foo>::value) 
       || 
       (std::is_base_of<TFoo<T>,T>::value && !std::is_same<T,TFoo<T>>::value), 
       "fail2" 
     ); 
};