Ошибка после перегрузки оператора +

String( const char* outStr ) 
{ 
    size = strlen(outStr);
    str = new char[size+1];
    strcpy( str, outStr );
}
 
String( const String& rhs ) { 
    size = rhs.size;
    str = new char[size+1];
    strcpy( str, rhs.str );
}

String& operator=( const String& rhs ) {
 
    if ( this != &rhs ) 
    {
        delete [] str; 
        size = rhs.size;
        str = new char[size+1];
        strcpy( str, rhs.str );
    }
    return *this;
}

#include <iostream>
#include <cstring>
#include <utility>
 
using namespace std;
 
class String
{
    char* str = nullptr;
    size_t size = 0;
 
public:
 
    String() = default;
 
    explicit String(const char* other_str)
    {
        if (other_str)
        {
            size = strlen(other_str);
            str = new char[size + 1];
            strcpy(str, other_str);
        }
    }
 
    String(const String& rhs)
    {
        if (rhs.size)
        {
            size = rhs.size;
            str = new char[size + 1];
            strcpy(str, rhs.str);
        }
    }
 
    String(String&& rhs) noexcept
    {
        str = rhs.str;
        size = rhs.size;
 
        rhs.str = nullptr;
        rhs.size = 0;
    }
 
    ~String()  { delete[] str; }
 
    void swap(String& rhs) noexcept
    {
        using std::swap;
        swap(str, rhs.str);
        swap(size, rhs.size);
    }
 
    String& operator =(String&& rhs) noexcept
    {
        if (this != &rhs)
        {
            delete [] str;
            str = rhs.str;
            size = rhs.size;
 
            rhs.str = nullptr;
            rhs.size = 0;
        }
        return *this;
    }
 
    String& operator =(String rhs)
    {
        rhs.swap(*this);
        return *this;
    }
 
    String& operator +=(const String& rhs)
    {
        if (rhs.size)
        {
            size_t new_size = size + rhs.size;
            char* new_str = new char[new_size + 1];
            strcpy(new_str, str);
            strcpy(new_str + size, rhs.str);
            delete [] str;
            str = new_str;
            size = new_size;
        }
        return *this;
    }
 
    void ShowStr() const { cout << str << endl; }
 
    void ShowSize() const { cout << size << endl; }
};
 
const String operator +(const String& lhs, const String& rhs)
{
    return (String(lhs) += rhs);
}
 
//namespace std
//{
//    template <>
//    void swap(String& lhs, String& rhs) noexcept (true)
//    {
//        lhs.swap(rhs);
//    }
//}
 
int main()
{
    String N1("hello");
    String N2("World");
    String N3("Its Me");
    String N4 = N1 + N2 + N3;
    N4.ShowStr();
    N4.ShowSize();
}

N1 + N2 = N3;

String N1, N2, N3;
...
// String& operator =(String rhs);
N1 = N2 + N3; // прощай, move-конструктор аргумента operator=(), я возвращаю const String из operator+

using std::swap;
swap(String_obj_1, String_obj_2);

namespace std {
    void swap(String& s1, String& s2) noexcept { s1.swap(s2); }
}

String& operator =(String&& rhs) noexcept
    {
        if (this != &rhs)
        {
            delete [] str;
            str = rhs.str;
            size = rhs.size;
 
            rhs.str = nullptr;
            rhs.size = 0;
        }
        return *this;
    }
 
    String& operator =(const String& rhs)
    {
        String temp(rhs);
        temp.swap(*this);
        return *this;
    }
 
namespace std
{
    template <>
    void swap(String& lhs, String& rhs) noexcept (noexcept(lhs.swap(rhs)))
    {
        lhs.swap(rhs);
    }
}

String& operator =(String&& rhs) & noexcept
    {
        if (this != &rhs)
        {
            delete [] str;
            str = rhs.str;
            size = rhs.size;
 
            rhs.str = nullptr;
            rhs.size = 0;
        }
        return *this;
    }
 
    String& operator =(const String& rhs) &
    {
        String temp(rhs);
        temp.swap(*this);
        return *this;
    }

String& operator =(String rhs) //for copy-and-swap
 
std::cout << std::is_nothrow_move_assignable<String>::value << "\n"; // false

String& operator =(String&& rhs) noexcept
String& operator =(String rhs) //for copy-and-swap
 
std::cout << std::is_nothrow_move_assignable<String>::value << "\n"; // false

String& operator =(String&& rhs) noexcept
String& operator =(const String& rhs) //for copy-and-swap with temporary object
 
std::cout << std::is_nothrow_move_assignable<String>::value << "\n"; // true

String& operator =(String rhs) noexcept //for copy-and-swap
 
std::cout << std::is_nothrow_move_assignable<String>::value << "\n"; // true