Question

This question follows this one : Function overloading and template deduction priority

Considering the following classes :

template<typename T1, typename T2> 
class Base {};

class Derived0 : public Base<double, double> {};

template<typename T1, typename T2, typename T3> 
class Derived1 : public Base<T1, T2> {};

template<typename T1, typename T2, typename T3, typename T4> 
class Derived2 : public Base<T3, T4> {};

And the following functions :

template<typename T> f(const T& x); // version A
template<typename T1, typename T2> f(const Base<T1, T2>& x); // version B

My problem is that f(double) will call version A (ok), f(Base<double, double>) will call version B (ok), but f(Derived1<double, double, double>) will call version A (see the link to the other question at the beginning).

Using C++11, how to block version A and force version B for all derived members of Base<T1, T2> whatever T1 and T2 are ?

Note : If possible, I would like to avoid to add helper classes and prefer adding members to the provided classes.

Answer 1

Here’s a trait that might work for you.

The trait class:

#include <type_traits>

template <typename, typename> struct Base { };

template <typename T> struct isbase
{
    typedef char yes;
    typedef yes no[2];

    template <typename U, typename V> static yes & test(Base<U, V> const &);
    static no & test(...);

    static bool const value = sizeof(test(std::declval<T>())) == sizeof(yes);
};

Application:

#include <iostream>

template <typename T>
typename std::enable_if<!isbase<T>::value>::type f(T const &)
{
    std::cout << "f(T const &)\n";
}

template <typename T1, typename T2>
void f(Base<T1, T2> const &)
{
    std::cout << "f(Base<T1, T2> const &)\n";
}

Example:

template<typename T1, typename T2, typename T3>
struct Derived1 : public Base<T1, T2> {};

int main()
{
    std::cout << isbase<double>::value << std::endl;
    std::cout << isbase<Base<int, char>>::value << std::endl;
    std::cout << isbase<Derived1<bool, bool, bool>>::value << std::endl;

    f(double{});
    f(Base<int, char>{});
    f(Derived1<bool, float, long>{});
}

---

Generalization: We can make a more general trait to check if a type derives from a template instance:

template <typename T, template <typename...> class Tmpl>
struct derives_from_template
{
    typedef char yes;
    typedef yes no[2];

    template <typename ...Args> static yes & test(Tmpl<Args...> const &);
    static no & test(...);

    static bool const value = sizeof(test(std::declval<T>())) == sizeof(yes);
};

Usage: derives_from_template<T, Base>::value etc.