Ufdjrw

I've tried to implement a commutative addition operator for one of my classes:

struct mytype

 constexpr mytype(othertype const &);
 constexpr mytype operator+(othertype const &rhs) const;
;

template<typename T>
constexpr auto operator+(T const &lhs, mytype const &rhs) -> decltype(rhs + lhs)

 return rhs + lhs;

The idea is that anything accepted on the right hand side also becomes acceptable on the left hand side as long as the right hand side is a mytype.

This works fine with icc and Visual Studio, and goes into an endless recursion resolving the decltype on gcc and clang (terminated when the maximum template depth is reached).

I can see that the endless recursion might in fact be more correct, as explained in the bug report: the specialization is needed before overload resolution takes place (because it is an input to overload resolution).

On the other hand the commercial compilers somehow manage (whether by accident or on purpose is probably debatable).

What is the correct behavior here?

Is it possible to avoid specifying a full list of classes for which operator+ is supposed to be commutative?

Compilable example:

struct othertype ;

struct mytype

 constexpr mytype() : value(1) 
 constexpr mytype(int v) : value(v) 
 constexpr mytype(othertype const &o) : value(2) // 1

 constexpr mytype operator+(mytype const &rhs) const
 
 return mytype(value + rhs.value);
 
 constexpr mytype operator+(othertype const &rhs) const // 2
 
 return mytype(value + 2);
 

 int value;
;

template<typename T>
constexpr auto operator+(T const &lhs, mytype const &rhs) -> decltype(rhs + lhs)

 return rhs + lhs;


void test()

 constexpr mytype mine;
 constexpr othertype other;

 constexpr auto result = other + mine;

 static_assert(result.value == 3);

The problem goes away when the conversion // 1 is removed, which isn't helpful in my use case. The separate addition operator // 2 is not sufficient to help resolve the decltype: overload resolution should have picked that up, but the problem happens before overload resolution.

The infinite recursion happens after specializing the template for T = othertype: converting othertype to mytype gives an addition expression with mytype on both sides, which again can be resolved through the template (even though a non-template exists).

You might restrict your template with SFINAE to discard operator+<mytype>(mytype const &lhs, mytype const &rhs):

template<typename T, typename std::enable_if<!std::is_same<T, mytype>::value, int>::type = 0>
constexpr auto operator+(T const &lhs, mytype const &rhs) -> decltype(rhs + lhs)

 return rhs + lhs;

Demo