参考std::string，设计并实现MyString类。 基本功能要求： 1）四种构造函数、析构函数； 2）重载赋值操作符=，使其正确完成String类型的赋值操作； 3）重载必要的操作符，实现形如 String a = “Hello ”; a += “World!”;的功能。 4）重载必要的操作符，实现形如 String a, b, c; c = a + b; 的操作过程。 5）重载必要的操作符，当完成 String a(“Hello ”); a << “world”; 的操作过程后，a所代表的字符串为”Hello world”。 6）重载必要的操作符，当完成 String a(“test”); std::cout << a; 的操作过程后，在屏幕上输入 test 7）重载必要的操作符，当完成 String a(“test”); a[2] = ’S’; 后，a所代表的字符串为”teSt”。

以下是MyString类的实现：

#include <cstring>
#include <iostream>

class MyString {
public:
    // 默认构造函数
    MyString() {
        m_data = new char[1];
        *m_data = '\0';
        m_size = 0;
    }
    // 从C字符串构造函数
    MyString(const char* str) {
        m_size = strlen(str);
        m_data = new char[m_size + 1];
        strcpy(m_data, str);
    }
    // 拷贝构造函数
    MyString(const MyString& other) {
        m_size = other.m_size;
        m_data = new char[m_size + 1];
        strcpy(m_data, other.m_data);
    }
    // 移动构造函数
    MyString(MyString&& other) noexcept : m_size(other.m_size), m_data(other.m_data) {
        other.m_size = 0;
        other.m_data = nullptr;
    }
    // 析构函数
    ~MyString() {
        delete[] m_data;
    }
    // 赋值操作符重载
    MyString& operator=(const MyString& other) {
        if (this == &other) {
            return *this;
        }
        delete[] m_data;
        m_size = other.m_size;
        m_data = new char[m_size + 1];
        strcpy(m_data, other.m_data);
        return *this;
    }
    // +=操作符重载
    MyString& operator+=(const MyString& other) {
        char* new_data = new char[m_size + other.m_size + 1];
        strcpy(new_data, m_data);
        strcat(new_data, other.m_data);
        m_size += other.m_size;
        delete[] m_data;
        m_data = new_data;
        return *this;
    }
    // +操作符重载
    friend MyString operator+(const MyString& lhs, const MyString& rhs) {
        MyString result(lhs);
        result += rhs;
        return result;
    }
    // <<操作符重载
    friend std::ostream& operator<<(std::ostream& os, const MyString& str) {
        os << str.m_data;
        return os;
    }
    // []操作符重载
    char& operator[](int index) {
        return m_data[index];
    }
    // =操作符重载
    MyString& operator=(const char* str) {
        delete[] m_data;
        m_size = strlen(str);
        m_data = new char[m_size + 1];
        strcpy(m_data, str);
        return *this;
    }
    // <<操作符重载
    MyString& operator<<(const char* str) {
        char* new_data = new char[m_size + strlen(str) + 1];
        strcpy(new_data, m_data);
        strcat(new_data, str);
        m_size += strlen(str);
        delete[] m_data;
        m_data = new_data;
        return *this;
    }

private:
    char* m_data;
    int m_size;
};

使用示例：

MyString a("Hello ");
MyString b("World!");
MyString c = a + b; // c代表的字符串为"Hello World!"
std::cout << c << std::endl; // 输出Hello World!
a << "world";
std::cout << a << std::endl; // 输出Hello world
MyString d = "test";
std::cout << d << std::endl; // 输出test
d[2] = 'S';
std::cout << d << std::endl; // 输出teSt