Operator overloading through inheritance causes ambiguity - c++

Question

I am writing some template library (lets say a linear algebra library) and got the next complicated bug, that I am able to reproduce only on GCC (Clang and VC++ work as expected).
The library consists of generic template types like
template<class C, int N>
class Vector;
template<class C, int N, int M = N>
class Matrix;
with some default implementations those are not used.
Also there are a set of interface classes like these
template<class C, int N>
struct VecMulInterface
{
Vector<C, N> operator*(const Vector<C, N>& v)
{
return static_cast<Matrix<C, N, N>*>(this)->mul_impl(v);
}
};
template<class C, int N>
struct ScalMulInterface
{
Matrix<C, N, N> operator*(const C& c)
{
return static_cast<Matrix<C, N, N>*>(this)->mul_impl(c);
}
};
and respective implementations providers
template<class C, int N>
struct MulImpl
{
public:
Vector<C, N> mul_impl(const Vector<C, N>& v) const
{
return {}; // imagine some logic here
}
Matrix<C, N, N> mul_impl(const C& c) const
{
return {}; // imagine some logic here
}
};
Finally I have template specializations those use everything from above:
template<class C>
class Vector<C, 2>
{
public:
C items[2];
// ...
};
template<class C>
class Matrix<C, 2, 2>:
public VecMulInterface<C, 2>,
public ScalMulInterface<C, 2>,
public MulImpl<C, 2>
{
public:
C items[4];
// ...
};
I try to use them like this:
Matrix<int, 2, 2> m;
Vector<int, 2> v1, v2;
v2 = m * v1; // <- error
Now the GCC spawns an error "error: request for member ‘operator*’ is ambiguous".
But!
If I change the line with error such that I use overloaded function instead of 'operator*'
v2 = m.mul_impl( v1 ); // <- NO error
OR if instead of inheriting from respective interfaces I place the operators out-of-class like this:
template<class C, int N>
Vector<C, N> operator*(const Matrix<C, N, N>& m, const Vector<C, N>& v)
{
return m.mul_impl(v);
}
template<class C, int N>
Matrix<C, N, N> operator*(const Matrix<C, N, N>& m, const C& c)
{
return m.mul_impl(c);
}
everything works just fine. (VC++ and Clang seems to work correctly in all cases)
Could anyone explain the reason for such behavior? Is this a compiler bug or I stepped onto "undefined behavior" somewhere in the code?

Answer 1

Functions in different scopes don't overload. For the member operator* case, the two functions are in VecMulInterface and ScalMulInterface respectively, so they are in different scopes. In the other two cases, the two functions are in the same scope.
You can use a using declaration to promote them to the same scope:
template<class C>
class Matrix<C, 2, 2> :
public VecMulInterface<C, 2>,
public ScalMulInterface<C, 2>,
public MulImpl<C, 2>
{
public:
using VecMulInterface<C, 2>::operator*;
using ScalMulInterface<C, 2>::operator*;
// ...
};
A more elegant approach is to use friend functions in the interfaces:
template <class C, int N>
struct VecMulInterface
{
friend Vector<C, N> operator*(const Matrix<C, N, N>& m, const Vector<C, N>& v)
{
return m.mul_impl(m, v);
}
};