仿照string类，写一个my_string类

#include <iostream>
#include <cstring>
using namespace std;
class my_string
{
private:
    char* str;
    int len;

public:
    //无参构造
    my_string()
    {
        memset(this, 0, sizeof(my_string));//全部清0
        cout<<"无参构造"<<endl;
    }
    //析构函数
    ~my_string()
    {
        delete [] this->str;
        str = nullptr;
        cout<<"析构函数"<<endl;
    }

    //有参构造
    my_string(char* str, int len)
    {
        this->str = new char[128];//开辟空间
        memcpy(this->str, str, len);//拷贝内容
        this->len = len;
        cout<<"有参构造"<<endl;
    }

    //拷贝构造
    my_string(const my_string& other)
    {
        this->str = new char[128];
        memcpy(this->str, other.str, other.len);
        this->len = other.len;
        cout<<"深拷贝"<<endl;
    }

    //拷贝赋值
    my_string& operator = (const my_string& other)//两个对象已经存在，只能赋值不能初始化
    {
        if(this==&other)//防止自己给自己赋值
        {
            return *this;
        }
        if(this->str != nullptr)//已经指向堆区空间
        {
            delete []str;//释放原有空间，避免内存泄露
            this->str = new char[128];//重新开辟空间
        }else//使用无参构造创建出来的对象，指针没有指向堆区空间
        {
            this->str = new char[128];//开辟空间
        }
        memcpy(this->str, other.str, other.len);//拷贝内容
        this->len = other.len;
        cout<<"拷贝赋值"<<endl;
        return *this;
    }

    //判空
    bool my_empty()
    {
        return this->str[0]==0? true:false;
    }
    //求长度
    int my_size()
    {
        int i = 0;
        while(this->str[i] != 0)
        {
            i++;
        }
        return i;
    }
    void show()
    {
        cout<<this->str<<'\t'<<this->len<<endl;
    }

};
int main()
{
    char buff[]="12345678";
    my_string s1(buff, sizeof(buff));
    s1.show();
    my_string s2 = s1;
    s2.show();
    my_string s3;
    s3.operator =(s2);
    s3.show();
    cout<< "1为空，0为非空： "<<s3.my_empty()<<endl;
    cout<<"字符串实际长度： "<<s3.my_size()<<endl;
    return 0;
}

测试结果：

有参构造
12345678        9
深拷贝
12345678        9
无参构造
拷贝赋值
12345678        9
1为空，0为非空： 0
字符串实际长度： 8
析构函数
析构函数
析构函数