Return type depending on the order in arithmetic operation. Is it correct?

Question

Consider following code snippet:

template <typename U>
struct Un {
    Un (int p) : n {p} {}

    U operator+ (U v) const {
        return U {n + v.n};
    }

    int n {};
};

struct R : Un<R> {
    using Un::Un;
};

struct D : Un<D> {
    using Un::Un;
    D (R v) : Un {v.n} {}
    operator R () const {
        return n;
    }
};

and usage is as follows:

template <typename T>
void what_type (T t) {
    std::cout << "type R = " << std::is_same<T, R>::value << std::endl;
    std::cout << "type D = " << std::is_same<T, D>::value << std::endl;
}

R r {10};
D d {10};

what_type (r+d);
what_type (d+r);

output is:

type R = 1
type D = 0
type R = 0
type D = 1

which means that if in the arithmetic expression R type occurs as the first one, the whole expression is of type R and if D type occurs firstly then the expression is of type D.

So, my understanding is like this:

in r+d firstly we create object of R type, then object of D type and because D has operator R() implemented, D object is converted to R, which gives us in fact r+r.

in d+r firstly we create object of D type, then object of R type and because D has constructor which takes R object it creates D object from previously created r, which gives us in fact d+d.

Is my understanding correct? Or are there other rules for that kind of situation?

Answer 1

Your understanding is flawed. You defined binary operator+ as a member function. That means that the left hand of the assignment is set in stone. For D and R it's D and R, respectively.

d+r is essentially the same thing as d.operator+(r), which for Un<D> returns D. It's the same thing in reverse for r+d.

In neither expression you "create" the left operand. The right one is indeed converted in both.