Limita il parametro modello C++ alla sottoclasse

Question

Come posso forzare un parametro modello T ad essere una sottoclasse di una classe specifica Baseclass? Qualcosa di simile a questo:

template <class T : Baseclass> void function(){ 
    T *object = new T(); 

} 

Answer 1

In questo caso si può fare:

template <class T> void function(){ 
    Baseclass *object = new T(); 

} 

Questo non compilare se T non è una sottoclasse di BaseClass (o T è BaseClass).

Answer 2

Chiamando le funzioni all'interno del modello esistenti nella classe base.

Se si tenta di creare un'istanza del modello con un tipo che non ha accesso a questa funzione, si riceverà un errore in fase di compilazione.

Answer 3

Si potrebbe utilizzare Boost Concept Check s' BOOST_CONCEPT_REQUIRES:

#include <boost/concept_check.hpp> 
#include <boost/concept/requires.hpp> 

template <class T> 
BOOST_CONCEPT_REQUIRES(
    ((boost::Convertible<T, BaseClass>)), 
(void)) function() 
{ 
    //... 
} 

Answer 4

Non hai bisogno di concetti, ma è possibile utilizzare SFINAE:

template <typename T> 
boost::enable_if< boost::is_base_of<Base,T>::value >::type function() { 
    // This function will only be considered by the compiler if 
    // T actualy derived from Base 
} 

Nota che questo istanziare la funzione solo quando la condizione è soddisfatto, ma non fornirà un errore ragionevole se la condizione non è soddisfatta.

Answer 5

per eseguire codice meno inutile in fase di esecuzione si può guardare: http://www.stroustrup.com/bs_faq2.html#constraints che prevede alcune classi che svolgono in modo efficiente il test di tempo di compilazione, e produrre i messaggi di errore più belli.

In particolare:

template<class T, class B> struct Derived_from { 
     static void constraints(T* p) { B* pb = p; } 
     Derived_from() { void(*p)(T*) = constraints; } 
}; 

template<class T> void function() { 
    Derived_from<T,Baseclass>(); 
} 

Answer 6

Con un C++ 11 compilatore compatibile, si può fare qualcosa di simile:

template<class Derived> class MyClass { 

    MyClass() { 
     // Compile-time sanity check 
     static_assert(std::is_base_of<BaseClass, Derived>::value, "Derived not derived from BaseClass"); 

     // Do other construction related stuff... 
     ... 
    } 
} 

Ho provato questo utilizzando il compilatore gcc 4.8.1 all'interno di un ambiente CYGWIN - quindi dovrebbe funzionare anche in ambienti * nix.