std :: is_base_of用于模板化矢量函数参数

Question

I want to provide two different implementations of an operator>> depending on whether the given type is a subclass of a special type:

class A {};

class B : public A{};
class C {};

template<typename T>
std::istream& operator>>(std::istream& is,
    std::vector<typename std::enable_if<std::is_base_of<A, T>::value>::type>& vec)
{
    std::cout << "Special case called" << std::endl;
    return is;
}

template<typename T>
std::istream& operator>>(std::istream& is,
    std::vector<T>& vec)
{
    std::cout << "General case called" << std::endl;
    return is;
}


void main(int argc, char **argv)
{
    std::vector<A> a;
    std::vector<B> b;
    std::vector<C> c;
    std::stringstream ss("A string");
    ss >> a;
    ss >> b;
    ss >> c;
}

Which prints

General case called
General case called
General case called

Changing the second operator definition to

template<typename T>
std::istream& operator>>(std::istream& is,
    std::vector<typename std::enable_if<!std::is_base_of<A, T>::value>::type>& vec)
{
    std::cout << "General case called" << std::endl;
    return is;
}

Does not compile because of

error C2678: binary '>>' : no operator found which takes a left-hand operand of type 'std::stringstream'

So I am probably using std::enable_if wrong. But what is correct? Are there problems with the templated std::vector here?

Answer 1

I don't think the std::enable_if is in the most desired position here, I would put it in the return type to enable SFINAE:

template<typename T>
typename std::enable_if<std::is_base_of<A, T>::value,std::istream>::type& 
operator>>(std::istream& is,std::vector<T>& vec)
{
    std::cout << "Special case called" << std::endl;
    return is;
}

template<typename T>
typename std::enable_if<!std::is_base_of<A, T>::value,std::istream>::type& 
operator>>(std::istream& is,std::vector<T>& vec)
{
    std::cout << "General case called" << std::endl;
    return is;
}

live demo

Answer 2

@Biggy's answer correctly demonstrates one way to do this properly. Here's an alternative that I find a bit more readable (along with some minor corrections and improvements):

template<typename T, typename std::enable_if<std::is_base_of<A, T>{}, int>::type = 0>
std::istream& operator >>(std::istream& is, std::vector<T>& vec) {
    std::cout << "Special case called\n";
    return is;
}

template<typename T, typename std::enable_if<!std::is_base_of<A, T>{}, int>::type = 0>
std::istream& operator >>(std::istream& is, std::vector<T>& vec) {
    std::cout << "General case called\n";
    return is;
}

Online Demo

Or better yet, using tag dispatching:

template<typename T>
std::istream& impl(std::istream& is, std::vector<T>& vec, std::true_type) {
    std::cout << "Special case called\n";
    return is;
}

template<typename T>
std::istream& impl(std::istream& is, std::vector<T>& vec, std::false_type) {
    std::cout << "General case called\n";
    return is;
}

template<typename T>
std::istream& operator >>(std::istream& is, std::vector<T>& vec) {
    return impl(is, vec, std::is_base_of<A, T>{});
}

Online Demo

In practice I've found the latter approach to be much more maintainable when the number of conditions is large, and result in more easily-deciphered error messages.

As to why your code doesn't work, the problem is that std::enable_if<std::is_base_of<A, T>::value>::type as a parameter type is not a deducible context for T , and there is no other parameter involving T to aide deduction. So because you don't explicitly specify T when you call it, the operator is simply not an eligible candidate to invoke because T is not known. When you then put the same attempted-SFINAE in the other overload, neither overload is viable and you get your error. A loose rule of thumb is: if you need typename (as with the enable_if usage), you are no longer in a deducible context.

Putting the enable_if in the return type or as a defaulted template parameter instead works because the parameter types (specifically the nice and simple std::vector<T>& ) are such that T is deducible.