Overloading template operator in derived class

Question

Given a base class and a derived class, which both provide conditionally enabled operators for specific parameter types using SFINAE:

#include <type_traits>

class Base
{
public:
    template<class T, std::enable_if_t<std::is_scalar_v<T>>* = nullptr>
    void operator>>(T& value) {
    }
};

class Derived: public Base
{
public:
    using Base::operator>>;

    template<class T, std::enable_if_t<!std::is_scalar_v<T>>* = nullptr>
    void operator>>(T& value) {
    }
};


int main(int argc, char *argv[])
{
    int foo;

    Base base;
    base >> foo; // this works

    Derived derived;
    derived >> foo; // this doesn't work, the operator from the base class is not considered
}

then calling an operator defined in the base class on an instance of the derived class will not work, even though it should have been made visible by the appropriate using Base::operator>>; declaration. Why? How can the operator from the base class be made usable without verbosely repeating the declaration/definition?

The problem does not occur if the operator in question is not a template in the base class.

Edit: Tested with msvc 15.9.7 as well as clang.

I reproduce the problem with clang++ but not with g++. I add another question: who's right? — max66, Mar 29 '19 at 18:57
Same problem with a simple template method (not necessarily an operator); I suppose it's a clang++ and msvc bug. — max66, Mar 29 '19 at 19:08

Michael Kenzel · Accepted Answer · 2019-03-29T19:41:33.810

I think the problem here is that a using declaration only brings the declarations of functions and function templates into a derived class that have signatures which are not overridden by members of the derived class [namespace.udecl]/15. So this code should indeed not compile.

Use free functions instead of class members to fix the problem:

#include <type_traits>

class Base
{
public:
    template<class T, std::enable_if_t<std::is_scalar_v<T>>* = nullptr>
    friend void operator>>(Base&, T& value) {
    }
};

class Derived: public Base
{
public:
    template<class T, std::enable_if_t<!std::is_scalar_v<T>>* = nullptr>
    friend void operator>>(Derived&, T& value) {
    }
};

int main()
{
    int foo;

    Base base;
    base >> foo;

    Derived derived;
    derived >> foo;
}

live example here

Overloading template operator in derived class

1 Answers1