c++仿照string类，完成myString 类

#include <iostream>
#include <cstring>
 
using namespace std;
 
class myString
{
    private:
        char *str;          //记录c风格的字符串
        int size;            //记录字符串的实际长度
    public:
        //无参构造
        myString():size(10)
        {
            str = new char[size+1];         //构造出一个长度为10的字符串
            strcpy(str,"");         //赋值为空串
            //cout<<"无参构造"<<endl;
        }
        //有参构造
        myString(const char *s)          //string  s("hello world")
        {
             size = strlen(s);
             str = new char[size+1];
             strcpy(str, s);
             //cout<<"有参构造"<<endl;
        }
        //拷贝构造  深拷贝
        myString(const myString &m):size(m.size){
            str = new char[size+1];
            strcpy(str, m.str);
           // cout<<"拷贝构造"<<endl;
        }
        //析构函数
        ~myString(){
            delete str;
            str = nullptr;
           // cout<<"析构函数"<<endl;
        }
        //拷贝赋值函数
 
        myString &operator=(const myString &s){
            size = s.size;
            //由于新字符串的长度不确定，所以先释放掉原来的内存空间，重新申请适合的内存空间
            delete str;
            str = new char[size+1];
            strcpy(str, s.str);
 
          //  cout<<"拷贝赋值"<<endl;
            return *this;
        }
        //判空函数
        bool str_empty(){
            return str == nullptr;
        }
        //size函数
        int str_size(){
            return size;
        }
        //c_str函数
        char *c_str(){
            char *c_string = new char[size + 1];
            strcpy(c_string, str);
            *(c_string+size) = 0;
            return c_string;
        }
        //at函数
        char &at(int pos){
            if(pos<0||pos>size-1){
                cout<<"参数错误"<<endl;
                return *str;
            }else{
                return *(str+pos);
            }
        }
        //加号运算符重载
        myString operator+(const myString &s){
            //定义一个临时字符串存储自身原本的数据
            myString tmp;
            //长度是自己的长度，加上目标字符串的长度
            tmp.size = size + s.size ;
            //在堆区重新申请一片合适大小的空间
            tmp.str = new char[tmp.size+1];
            //先拷贝自己原本的数据，放在前面
            strcpy(tmp.str, str);
            //定义一个指针指向用来保存目标字符串的位置
            char *tstr = tmp.str + size;
            //将目标字符串拷贝入空间
            strcpy(tstr, s.str);
 
            tstr = nullptr;
 
            return tmp;
        }
        myString operator+(const char* s){
            //定义一个临时字符串存储自身原本的数据
            myString tmp;
            //长度是自己的长度，加上目标字符串的长度
            tmp.size = size + strlen(s) ;
            //在堆区重新申请一片合适大小的空间
            tmp.str = new char[tmp.size+1];
            //先拷贝自己的数据，放在前面
            strcpy(tmp.str, str);
            //定义一个指针指向用来保存目标字符串的位置
            char *tstr = tmp.str + size;
            //将目标字符串拷贝入空间
            strcpy(tstr, s);
 
            tstr = nullptr;
 
            return tmp;
        }
        //等号运算符重载
        myString &operator=(const char* s){
            size = strlen(s);
            //由于新字符串的长度不确定，所以先释放掉原来的内存空间，重新申请适合的内存空间
            delete str;
            str = new char[size+1];
            strcpy(str, s);
 
            return *this;
        }
        //加等于运算符重载
        myString &operator+=(const myString &s){
            //定义一个临时字符串存储自身原本的数据
            myString tmp(*this);
            //长度是原来自己的长度，加上目标字符串的长度
            size = tmp.size + s.size ;
            //释放自身原本指向的堆区空间
            delete str;
            //在堆区重新申请一片合适大小的空间
            str = new char[size+1];
            //先拷贝自己原本的数据，放在前面
            strcpy(str, tmp.str);
            //定义一个指针指向用来保存目标字符串的位置
            char *tstr = str + tmp.size;
            //将目标字符串拷贝入空间
            strcpy(tstr, s.str);
 
            tstr = nullptr;
 
            return *this;
        }
        myString &operator+=(const char*s){
            //定义一个临时字符串存储自身原本的数据
            myString tmp(*this);
            //长度是原来自己的长度，加上目标字符串的长度
            size = tmp.size + strlen(s);
            //释放自身原本指向的堆区空间
            delete str;
            //在堆区重新申请一片合适大小的空间
            str = new char[size+1];
            //先拷贝自己原本的数据，放在前面
            strcpy(str, tmp.str);
            //定义一个指针指向用来保存目标字符串的位置
            char *tstr = str + tmp.size;
            //将目标字符串拷贝入空间
            strcpy(tstr, s);
 
            tstr = nullptr;
 
            return *this;
        }
        //关系运算符重载（>）
        bool operator>(const myString &s){
            int i=0;
            while (*(str+i)==*(s.str+i)&&*(str+i)!=0&&*(s.str+i)!=0){
                i++;
            }
            return *(str+i)-*(s.str+i)>0;
        }
        bool operator<(const myString &s){
            int i=0;
            while (*(str+i)==*(s.str+i)&&*(str+i)!=0&&*(s.str+i)!=0){
                i++;
            }
            return *(str+i)-*(s.str+i)<0;
        }
        bool operator==(const myString &s){
            int i=0;
            while (*(str+i)==*(s.str+i)&&*(str+i)!=0&&*(s.str+i)!=0){
                i++;
            }
            return *(str+i)==*(s.str+i);
        }
        bool operator!=(const myString &s){
            int i=0;
            while (*(str+i)==*(s.str+i)&&*(str+i)!=0&&*(s.str+i)!=0){
                i++;
            }
            return *(str+i)-*(s.str+i)!=0;
        }
        bool operator<=(const myString &s){
            int i=0;
            while (*(str+i)==*(s.str+i)&&*(str+i)!=0&&*(s.str+i)!=0){
                i++;
            }
            return *(str+i)-*(s.str+i)<=0;
        }
        bool operator>=(const myString &s){
            int i=0;
            while (*(str+i)==*(s.str+i)&&*(str+i)!=0&&*(s.str+i)!=0){
                i++;
            }
            return *(str+i)-*(s.str+i)>=0;
        }
        //中括号运算符重载
        char &operator[](int pos){
            if(pos<0||pos>size-1){
                cout<<"参数错误"<<endl;
                return *str;
            }else{
                return *(str+pos);
            }
        }
        //展示函数
        void show(){
            cout<<str<<endl;
        }
};
 
int main()
{
    myString s1("hello ");
    myString s2 = "world";
    myString s3;
    s3 = s1+s2;
    cout<<"s3:";
    s3.show();
    myString s4 = s3;
    cout<<"s4:";
    s4.show();
    s1+=s2;
    cout<<"s1:";
    s1.show();
    s1[5] = 'O';
    cout<<"s1:";
    s1.show();
    s1.at(5) = 'o';
    s1.at(4) = 'O';
    cout<<"s1:";
    s1.show();
    myString s5("hellow");
 
 
    return 0;
}