Question

I have to implement a non-member function isHomogenous(Triple triple) for a template class defined as:

template <typename T1, typename T2, typename T3>
    class Triple
{
public:
    Triple()
    { }
    Triple(const T1 &a, const T2 &b, const T3 &c) : a(a), b(b), c(c)
    { }
...

The isHomogenous function should return a bool value indicating whether all of the three values in the parameter triple are of the same type. I have tried:

template <typename T> bool isHomogenous(Triple<T, T, T> triple) {
    return true;
}

template <typename T1, typename T2, typename T3> bool isHomogenous(Triple<T1, T2, T3> triple) {
    return false;
}

This doesn’t work, can you hint me on a solution?

Answer 1

A function template cannot be partially specialized.

One alternative is to define it as a static member function (or in your case just a value!) of a class template, and then just provide an ordinary function template wrapper, like …

#include <type_traits>

template< class T1, class T2, class T3 >
struct Blah {};

namespace detail {
    template< class T1, class T2, class T3 >
    struct IsHomogenous { static bool const yes = false; };

    template< class T >
    struct IsHomogenous< T, T, T > { static bool const yes = true; };
}  // namespace detail

template< class T1, class T2, class T3 >
bool isHomogenous( Blah< T1, T2, T3 > )
{
    return detail::IsHomogenous< T1, T2, T3 >::yes;
}

#include <iostream>
int main()
{
    using namespace std;
    wcout << boolalpha
        << isHomogenous( Blah< double, char, void >() ) << " "
        << isHomogenous( Blah< int, int, int >() )
        << endl;
}

and another way is to use C++11 std::is_same:

#include <type_traits>

template< class T1, class T2, class T3 >
struct Blah {};

template< class T1, class T2, class T3 >
bool isHomogenous( Blah< T1, T2, T3 > )
{
    using std::is_same;
    return is_same< T1, T2 >::value && is_same< T2, T3 >::value;
}

#include <iostream>
int main()
{
    using namespace std;
    wcout << boolalpha
        << isHomogenous( Blah< double, char, void >() ) << " "
        << isHomogenous( Blah< int, int, int >() )
        << endl;
}