C++11 overload of `M operator+(M&&,M&&)` - operator-overloading

Question

Update: clarification, more clear focus and shortened example:
Can I circumvent the M op+(M&&,M&&) overload? Assuming, I want good handling of RValues? I guess the other three overloads are required.
Reason why I have the (&&,&&) overload in the first place:
Normally I would not provide M op+(&&,&&), but I seem to need it: When providing overloads for (&&,&) and (&,&&) the compiler gets into an ambiguity. Is there a better way to resolve it then to add another implementation variant?
You can also look at the complete code.
struct Matrix {
...
// 2ary ops
friend Matrix operator+(const Matrix &a, Matrix &&b ) { b+=a; return move(b); }
friend Matrix operator+(Matrix &&a, const Matrix &b) { a+=b; return move(a); }
friend Matrix operator+(const Matrix &a, Matrix v) { v+=a; return v; }
friend Matrix operator+(Matrix &&a, Matrix &&b) { a+=b; return move(a); }
// ... same for operator*
// ... assume impl of operator+=,*= and move semantics
};
int main() {
Matrix a{2},b{3},c{4},d{5};
Matrix x = a*b + c*d; // reuires &&,&& overload
std::cout << x << std::endl;
}

Answer 1

The following helper function returns the first value if it an rvalue, otherwise the second value (which may be an rvalue, but may not be).
template <class T1, class T2>
typename std::enable_if<! std::is_reference<T1>::value, T1&&>::type
get_rvalue(T1&& t1, T2&& t2) { return std::forward<T1>(t1); }
template <class T1, class T2>
typename std::enable_if<std::is_reference<T1>::value, T2&&>::type
get_rvalue(T1&& t1, T2&& t2) { return std::forward<T2>(t2); }
The following helper function returns the other value not returned above.
template <class T1, class T2>
typename std::enable_if<! std::is_reference<T1>::value, T1&&>::type
get_non_rvalue(T1&& t1, T2&& t2) { return std::forward<T2>(t2); }
template <class T1, class T2>
typename std::enable_if<std::is_reference<T1>::value, T2&&>::type
get_non_rvalue(T1&& t1, T2&& t2) { return std::forward<T1>(t1); }
This just compares if two types are the same, ignoring references and const.
template <class T1, class T2>
struct is_same_decay : public std::is_same<
typename std::decay<T1>::type,
typename std::decay<T2>::type
> {};
Then we can do just one overload for each function (using templates) like the following:
// 2ary ops
template <class M1, class M2>
friend typename std::enable_if<
is_same_decay<M1, Matrix>::value &&
is_same_decay<M2, Matrix>::value,
Matrix>::type
operator+(M1&& a, M2&& b)
{
Matrix x = get_rvalue(std::forward<M1>(a), std::forward<M2>(b));
x += get_non_rvalue(std::forward<M1>(a), std::forward<M2>(b));
return x;
}
template <class M1, class M2>
friend typename std::enable_if<
is_same_decay<M1, Matrix>::value &&
is_same_decay<M2, Matrix>::value,
Matrix>::type
operator*(M1&& a, M2&& b)
{
Matrix x = get_rvalue(std::forward<M1>(a), std::forward<M1>(b));
x *= get_non_rvalue(std::forward<M1>(a), std::forward<M1>(b));
return x;
}
Note above, if either M1 or M2 is an rvalue, get_rvalue(a, b) will return an rvalue, hence in this case Matrix x will be populated by a move, not a copy. Named return value optimisation will probably ensure that there is no copy (or even move) required into the return value, as x will be constructed in the place of the return value.
Full code is here.

Answer 2

Matrix& operator=(Matrix&& o) { swap(*this,o); };
First, your Matrix class has nothing (as of yet) that needs moving, so you shouldn't bother writing one. Like a copy constructor, only define one if you need to. Let the compiler take care of it unless you have a legitimate need (like storing a naked pointer).
Second, that function of yours doesn't move; it swaps. An "idiomatic" swap-based move involves a temporary, like this:
Matrix temp;
swap(o, temp);
swap(temp, *this);
friend Matrix operator+(const Matrix &a, Matrix &&b ) { b+=a; return move(b); }
friend Matrix operator+(Matrix &&a, const Matrix &b) { a+=b; return move(a); }
friend Matrix operator+(const Matrix &a, Matrix v) { v+=a; return v; }
friend Matrix operator+(Matrix &&a, Matrix &&b) { a+=b; return move(a); }
What are you trying to accomplish here? Again, your object doesn't have anything that gets moved; there's no point in doing this. Just because you could move something, doesn't mean you should. If you really wanted to cut down on code duplication, you would do things normally:
friend Matrix operator+(const Matrix &a, const Matrix &b) { Matrix temp = a + b; return temp; }