Automatically implement operator+ using CRTP I have multiple classes that should support addition. For each of them, the operator += is implemented as T&amp; operator+=(const T&amp; rhs). I also want to add the operator +, but this implementation will use += and will therefore be similiar in all classes. My idea was to implement a template class using the Curiously Recurring Template Pattern that provides an implementation. The result is code like this:

template&lt;class T&gt;
class Sumable {
private:
    Sumable() = default;

public:
    Sumable(const Sumable&lt;T&gt;&amp;) = delete;
    Sumable(Sumable&lt;T&gt;&amp;&amp;) = delete;

    T operator+(const T&amp;) const&amp;;
    T operator+(const T&amp;) &amp;&amp; ;
    T operator+(T&amp;&amp;) const&amp;;
    T operator+(T&amp;&amp;) &amp;&amp; ;

    friend T;
};

template&lt;class T&gt;
inline T Sumable&lt;T&gt;::operator+(const T &amp; rhs) const&amp;
{
    T result(*static_cast&lt;const T*&gt;(this));
    return std::move(result += rhs);
}

template&lt;class T&gt;
inline T Sumable&lt;T&gt;::operator+(const T &amp; rhs) &amp;&amp;
{
    return std::move&lt;T&amp;&gt;(*static_cast&lt;T*&gt;(this) += rhs);
}

template&lt;class T&gt;
inline T Sumable&lt;T&gt;::operator+(T &amp;&amp; rhs) const&amp;
{
    return std::move(rhs += *this);
}

template&lt;class T&gt;
inline T Sumable&lt;T&gt;::operator+(T &amp;&amp; rhs) &amp;&amp;
{
    return std::move(rhs += *this);
}


Classes that support addition would extend from Sumable&lt;T&gt; like for example class Vector : public Sumable&lt;Vector&gt; 

The operator is overloaded four times to prevent the creation of unnecessary temporary objects. The idea is described here https://stackoverflow.com/questions/6006527/overloading-on-r-value-references-and-code-duplication, but I return T by value to prevent the problems described in this question.
I also follow this idea https://stackoverflow.com/questions/11224838/prevent-user-from-deriving-from-incorrect-crtp-base/11241079 to prevent incorrect use of the class.

In a simple test, this worked like expected. Are there any edge cases in which this design can cause problems? And is it a good idea to use this design in production code?

Edit
The code I used to test this, compiles under MSVS 2017:

#include "stdafx.h"
#include &lt;iostream&gt;
#include "Sumable.h"

using namespace std;

struct Test : public Sumable&lt;Test&gt;{
    int data;

    Test(int data) : data(data) {};
    Test(const Test&amp; that) : data(that.data) 
    {
        cout &lt;&lt; "copy" &lt;&lt; endl;
    };
    Test(Test&amp;&amp; that) : data(that.data) 
    {
        cout &lt;&lt; "move" &lt;&lt; endl;
    };
    Test&amp; operator+=(const Test&amp; that) {
        this-&gt;data += that.data;
        return *this;
    }
};
int main()
{
    Test a{ 1 };
    Test b{ 2 };
    Test c{ 3 };
    cout &lt;&lt; (a + b + c + a + b + c).data &lt;&lt; endl;
    return 0;
}
Missing header
I had to #include &lt;utility&gt; to get a definition for std::move().
Don't delete your destructors
You didn't show us your tests, but I struggled to get my obvious code to compile.  Part of the reason was the deleted constructors; I changed the default constructor to protected and made the copy/move constructors to protected and = default, and then I was able to inherit without having to explicitly write copy/move construct/assign in my subclass:
struct Test : public Sumable&lt;Test&gt;
{
    int i;
    Test(int i) : i(i) {}
    Test&amp; operator+=(const Test&amp; t) { i += t.i; return *this; }
};

There's no need to move() when returning
I know the question is tagged C++11, but even there, any benefit is questionable (and particularly unlikely to exist when the function is inlined).  When you move the code to a more recent standard, it's actively harmful.
Pass by value instead of copying from a reference
If you can insist on the usual x + y == y + x (which seems to be assumed already, given the third and fourth methods, which compute rhs += *this), then you can pass rhs by value (since we need to copy one of the arguments), which will be move-constructed as and when appropriate:
template&lt;class T&gt;
inline T Sumable&lt;T&gt;::operator+(T rhs) const
{
    return rhs += *static_cast&lt;const T*&gt;(this);
}

That's now one method instead of four.
N.B. I had to introduce the static_cast there, as your code wouldn't compile with GCC 8.0 without it.
Consider free functions
Inheritance isn't necessarily the best solution to everything in C++.  You may be better writing free functions instead (in the same namespace as your classes, or in a specific includable namespace, along the lines of std::rel_ops).
Here's a start, including a basic test:
#include &lt;type_traits&gt;

namespace arithmetic_ops
{
    template&lt;typename T, typename U&gt;
    auto operator+(T t, U&amp;&amp; u)
        -&gt; typename std::remove_reference&lt;decltype(t+=u)&gt;::type
    {
        return t += u;
    }

    template&lt;typename T, typename U&gt;
    auto operator+(T&amp;&amp; t, U u)
        -&gt; typename std::enable_if&lt;!std::is_assignable&lt;T,U&gt;::value,
                                   decltype(operator+(u,t))&gt;::type
    {
        return u + t;
    }
}


namespace test {
    struct Test
    {
        int i;
        Test(int i) : i(i) {}
        Test&amp; operator+=(const Test&amp; t) { i += t.i; return *this; }
    };
}

int main()
{
    using namespace arithmetic_ops;

    test::Test a(4);
    test::Test b(-4);
    return (0 + a + b + 0).i;
}

I've used forwarding references above for the non-copied argument - that allows us to have only one method for the class-first case (the second version being an override for cases such as 0 + a where the first argument must be converted).
The enable_if avoids ambiguity when t + u and u + t are both possible.
The ::type and ::value members get shortened from C++14, with _t and _v suffixes to the names (e.g. std::remove_reference_t&lt;decltype(t+=u)&gt; and std::enable_if_t&lt;!std::is_assignable_v&lt;T,U&gt;, decltype(operator+(u,t))&gt;.
a and/or b can be made const in this test without breaking it.