代码

class String{
private:
    char* str;
    int len;
public:
    // 默认构造函数
    String () {
        len = 0;
        str = nullptr;
    }

    // 构造函数
    String (const char* s) {
        len = std::strlen(s);
        str = new char[len + 1];
        std::strcpy(str, s);
    }

    // 拷贝构造函数
    String (const String& st) {
        // 拷贝构造函数的参数必须是引用类型而不能是类类型，类类型属于传值，而传值的方式会调用该类的拷贝构造函数，从而造成无穷递归地调用拷贝构造函数
        // const，防止对实参的意外修改；能够接受 const 和 非 const 类型；使函数能够正确生成并使用临时对象
        len = st.len;
        str = new char[len + 1];
        std::strcpy(str, st.str);
    }
    // 移动构造函数
    String (String&& st) noexcept {
        len = st.len;
        str = st.str;
        // 上面的语句拿了 st 的资源，所以要下面要置空，否则会有多个指针指向同一块内存的危险
        st.str = nullptr; st.len = 0;
    }

    // 赋值运算符
    String& operator= (const String& st) {
        if (this == &st) return  *this;
        delete[] str; // 注意这里是赋值，原来的对象本身有内容，所以要释放掉
        len = st.len;
        str = new char[len + 1];
        std::strcpy(str, st.str);
        return *this;
    }
    // 移动赋值运算符
    String& operator= (String&& st) noexcept {
        if (this == &st) return  *this;
        delete[] str; // 注意这里是赋值，原来的对象本身有内容，所以要释放掉
        len = st.len;
        str = st.str;
        // 上面的语句拿了 st 的资源，所以要下面要置空，否则会有多个指针指向同一块内存的危险
        st.str = nullptr; st.len = 0;
        return *this;
    }

    // 读写非 const 的对象
    char& operator[] (int i) {
        return str[i];
    }
    // 读 const 的类对象
    const char& operator[] (int i) const{
        return str[i];
    }

    // 重载 << 运算符；写成友元是为了可以这样使用（cout << object）否则只能（object << cout，因为二元运算符重载为成员函数的话只能设置一个参数作为右侧运算量，而左侧运算量就是对象本身）
    friend ostream& operator<< (ostream& os, const String& st) {
        os << st.str;
        return os; // 返回 ostream& 是为了链式调用
    }

    ~String() {
        delete[] str; len = 0;
    }
};

参考

• 《C++ Primer Plus 中文版》 chapter 12