封装一个mystring类

#include <iostream>
#include <cstring>

using namespace std;

class myString
{
    private:
        char *str;          //记录c风格的字符串
        int size;            //记录字符串的实际长度
    public:
        //无参构造
        myString():size(10)
        {
            str = new char[size];         //构造出一个长度为10的字符串
            strcpy(str,"");
        }
        //有参构造
        myString(const char *s)          //string  s("hello world")
        {
            size = strlen(s);
            str = new char[size+1];
            strcpy(str, s);
        }

        //拷贝构造
        myString(const myString &other):size(other.size)
        {
            this->str = new char[other.size+1];
            strcpy(this->str,other.str);
        }
        //析构函数
        ~myString()
        {
            delete str;
            //cout<<"析构函数"<<endl;
        }
        //判空函数
        bool empty()
        {
            return size==0;
        }
        //s_size函数
        int s_size()
        {
            return size;
        }
        //c_str函数
        char *c_str()
        {
            return str;
        }
        //at函数
        char &at(int pos)
        {
            if(pos<size && pos>=0)
                return *(str+pos);
            cout<<"越界访问"<<endl;//没有返回值报警告
        }
        //拷贝赋值函数，运算符=重载
        myString &operator=(const myString &other)
        {
            this->size = other.size;
            strcpy(this->str,other.str);
            return *this;
        }
        //运算符[]重载
        char &operator[](int pos)
        {
            return *(str+pos);
        }
        //运算符+重载
        const myString operator+(const myString &R) const
        {
            myString temp;
            strcpy(temp.str,this->str);
            strcat(temp.str,R.str);
            temp.size = this->size + R.size;
            return temp;
        }
        //运算符==重载
        bool operator==(const myString &O)
        {
            return (strcmp(this->str,O.str)==0 && this->size==O.size);
        }
        //运算符!=重载
        bool operator!=(const myString &O)
        {
            return (strcmp(this->str,O.str)!=0 || this->size!=O.size);
        }
        //运算符<重载
        bool operator<(const myString &O)
        {
            return strcmp(this->str,O.str)<0 ;
        }
        //运算符>重载
        bool operator>(const myString &O)
        {
            return strcmp(this->str,O.str)>0 ;
        }
        //运算符<=重载
        bool operator<=(const myString &O)
        {
            return strcmp(this->str,O.str)<=0 ;
        }
        //运算符>=重载
        bool operator>=(const myString &O)
        {
            return strcmp(this->str,O.str)>=0 ;
        }
        //将运算符<<重载函数设为友元函数
        friend ostream &operator<<(ostream &L,const myString &R);
        //将运算符>>重载函数设为友元函数
        friend istream &operator>>(istream &L,myString &R);
};

//全局函数，运算符<<重载
ostream &operator<<(ostream &L,const myString &R)
{
    L<<R.str;
    return L;
}

//全局函数，运算符>>重载
istream &operator>>(istream &L,myString &R)
{
    string s;
    cin>>s;
    int size = strlen(s.c_str());
    R.str = new char[size+1];
    strcpy(R.str,s.c_str());
    R.size = size;
    return L;
}

int main()
{
    //无参构造
    myString s1;
    char *s2 = s1.c_str();//c_str函数
    cout<<"s1=s2="<<s2<<endl;

    //有参构造
    myString s3("hello");
    cout<<"s3="<<s3<<endl;

    //拷贝构造
    myString s4(s3);
    cout<<"s4="<<s4<<endl;

    //at函数
    cout<<s4.at(1)<<endl;
    s4.at(0) = 'H';
    cout<<"s4 = "<<s4<<endl;
    cout<<s4.at(8)<<endl;//使用at函数越界访问

    //s_size函数
    cout<<s4.s_size()<<endl;

    //判空
    cout<<"s4是否为空："<<boolalpha<<s4.empty()<<endl;
    cout<<"s1是否为空："<<boolalpha<<s1.empty()<<endl;

    //运算符=重载
    myString s5("nihao");
    myString s6;
    s6 = s5;
    cout<<"s6 = "<<s6<<endl;

    //运算符[]重载
    cout<<"s5[1] = "<<s5[1]<<endl;

    //运算符+重载
    myString s7 = s3 + s5;
    cout<<"s7 = "<<s7<<endl;

    //运算符==重载
    if(s5 == s6)
        cout<<"s5 == s6"<<endl;

    //运算符!=重载
    if(s3 != s4)
        cout<<"s3 != s4"<<endl;

    //运算符<重载
    if(s3<s5)
        cout<<"s3<s5"<<endl;

    //运算符>重载
    if(s5>s3)
        cout<<"s5>s3"<<endl;

    //运算符<=重载
    if(s3<=s5)
        cout<<"s3<=s5"<<endl;
    if(s5 <= s6)
        cout<<"s5 <= s6"<<endl;


    //运算符>=重载
    if(s5>=s3)
        cout<<"s5>=s3"<<endl;
    if(s5 >= s6)
        cout<<"s5 >= s6"<<endl;

    //运算符>>,<<重载
    myString s8;
    cout<<"请输入"<<endl;
    cin>>s8;
    cout<<"s8="<<s8<<endl;
    cout<<s8.s_size()<<endl;

    return 0;
}