手撕string 理解右值

class Mystring
{
public:
    Mystring() : data(new char[1]{'\0'}), length(0) {};
    ~Mystring() {
        delete []data;
    }
    Mystring(const char * str) { // 普通构造 带explicit 无法实现 Mystring a = "123"
        if (!str) {
            data = new char[1]{'\0'};
            length = 0;
        } else {
            length = std::strlen(str);
            data = new char[length + 1];
            strcpy(data, str);
        }
    }
    Mystring(const Mystring &b) { // 拷贝构造 深拷贝自己可控制
        length = b.length;
        data = new char[length + 1];
        strcpy(data, b.data);
    }

    Mystring(Mystring && b) noexcept : data(b.data), length(b.length){ 
        b.data = nullptr; // 移动拷贝 释放b对象 noexcept 适配vector容器检查 vector push back 扩容会调用移动拷贝 速度快
        b.length = 0;
    }

    Mystring &operator=(const Mystring &b) { // 拷贝赋值 
        if (this == &b) {
            return *this;
        }
        delete [] data;
        length = b.length;
        data = new char[length + 1];
        std::strcpy(data, b.data);
        return *this;
    }

    Mystring &operator=(Mystring &&b) noexcept { // 移动赋值 noexpect同理
        if (this == &b) {
            return *this;
        }
        delete [] data;
        length = b.length;
        data = b.data;
        b.data = nullptr;
        b.length = 0;
        return *this;
    }
    
    Mystring operator+(const Mystring &b) {
        Mystring res;
        res.length = b.length + length;
        res.data = new char[res.length + 1];
        strcpy(res.data, data);
        strcat(res.data, b.data);
        return res;
    }
    
    char &operator[](size_t len) {
        return data[len];
    }
    
    const char &operator[](size_t len) const{
        return data[len];
    }
    
    const char* c_str() const{
        return data;
    }

private:
    char *data;
    size_t length;
};

    Mystring a = "123"; // 有参构造 隐式转换 
    Mystring b = a; // 拷贝构造
    Mystring c;
    Mystring e;
    c = a; // 拷贝赋值
    Mystring d = std::move(a); // 移动构造
    e = std::move(b); // 移动赋值