Comment faire en sorte que les surcharges de fonctions modélisées acceptent des classes dérivées de classes de base différentes ?

Question

Je veux pouvoir 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 être dérivé de BaseY (comment spécifier ce genre de choses ?), et je veux pouvoir l'appeler en tant que

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 puis-je l'implémenter ? Si ce n'est pas possible, existe-t-il un moyen de faire en sorte qu'une fonction template n'accepte que certains types, mais qu'elle soit quand même implicitement instanciée ? Je ne peux pas simplement faire en sorte que les surcharges de f acceptent la classe de base parce que j'ai besoin du type de la classe dérivée.

Answer 1

Vous pouvez utiliser is_base_of de Boost.TypeTraits comme suit :

#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 Boost.TypeTraits n'est qu'un en-tête, vous n'avez donc pas besoin de lier quoi que ce soit.

Answer 2

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

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

C'est ce qui me semble le plus simple. Vous pourriez utiliser la fonction is_base_of si vous ne souhaitez pas fournir l'argument explicite du modèle.