Comment faire pour avoir des surcharges de fonction de modèle accepter des classes dérivées de différentes classes de base?

Question

Je veux être en mesure de définir

template <class TX> 
void f(const TX &x){ ... } 
template <class TY> 
void f(const TY &x){ ... } 

où TX doit être dérivé de BaseX et TY doit provenir de la BaseY (comment puis-je préciser ce genre de chose?), Et je veux être en mesure d'appeler comme

f(DerivedX<T>()) 

il est très important que je puisse éviter de spécifier les paramètres du modèle. Est-ce possible, et si oui, comment l'implémenterais-je? Si ce n'est pas possible, y a-t-il un moyen de faire en sorte qu'une fonction modélisée n'accepte que certains types, mais qu'elle soit implicitement instanciée? Je ne peux pas faire que les surcharges de f acceptent la classe de base car j'ai besoin du type de la classe dérivée.

Answer 1

Vous pouvez utiliser is_base_of de Boost.TypeTraits comme ceci:

#include <boost/type_traits.hpp> 
#include <boost/utility.hpp> 

class BaseX { }; 
class BaseY { }; 

class DerivedX : public BaseX { }; 
class DerivedY : public BaseY { }; 

template <typename TX> 
boost::enable_if<boost::is_base_of<BaseX, TX>, void>::type 
f(const TX& x) 
{ 
} 

int main(int argc, char** argv) 
{ 
    DerivedX x; 
    DerivedY y; 

    f(x); // compiles 
    f(y); // will cause a compilation error 
} 

La bibliothèque est Boost.TypeTraits tête seule, de sorte que vous n'avez pas besoin de lier quoi que ce soit dans

Answer 2

template <class TX> 
void f(const BaseX &x){ ... } 
template <class TY> 
void f(const BaseY &x){ ... } 

f<DerivedX>(DerviedX<T>()) 

Cela me semble le plus facile. Vous pouvez utiliser is_base_of boost si vous ne souhaitez pas fournir l'argument de modèle explicite.