在myString基础上，将能够重载的运算符全部进行重载

在myString基础上，将能够重载的运算符全部进行重载

#include <iostream>
#include <cstring>
using namespace std;

class myString
{
private:
    int size;
    char *str;


public:
    myString(){}
    myString(const char *s)     //有参构造
    {
        size = strlen(s);
        str = new char[size + 1];
        strcpy(str,s);
    }

    //拷贝构造函数
    myString(const myString &other):size(other.size),str(new char(*(other.str)))
    {
        cout << "拷贝构造" << endl;
    }
/*
    //析构函数
    ~myString()
    {
        delete str;
    }*/

    //判空函数
    bool Empty()
    {
        return size == -1;
    }

    void show()
    {
        cout << "str=" << str <<endl;
    }

    //size函数
    int str_len ()const
    {
        return size;
    }

    //c_str函数
    const char *c_str ()const
    {
        return str;
    }

    //at函数
    char &at(int pos)
    {
        return str[pos];
    }

    //operator= 字符赋值
    myString & operator=(const myString &R)
    {
        if(this != &R)
        {
            size = R.size;
            str = new char[R.size + 1];
            strcpy(str, R.str);
        }
        return *this;
    }

    //operator[] 按位置访问字符
    char &operator[](int pos)
    {
        return str[pos];
    }

    //operator+ 字符连接
    myString operator+(const myString &R)const
    {
        myString temp;                      //定义临时变量
        temp.size = this->size + R.size;    //临时变量扩展长度
        temp.str = new char[temp.size + 1];
        strcpy(temp.str, str);
        strcat(temp.str, R.str);
        return temp;

    }

    //operator== 字符串相等
    bool operator==(const myString &R) const
    {
        if (size != R.size)
        {
            return false;
        }
        return strncmp(str, R.str, size + 1) == 0;
        }

    //operator!= 字符串不等
    bool operator!=(const myString &R)
    {
        return (this->str != R.str);
    }


    //operator<  字符串大
    bool operator<(const myString &R)
    {
        return (this->str < R.str);
    }
    //operator>  字符串小
    bool operator>(const myString &R)
    {
       return (this->str > R.str);
    }
    //operator<=
    bool operator<=(const myString &R)
    {
        return (this->str <= R.str);
    }
    //operator>=
    bool operator>=(const myString &R)
    {
        return (this->str >= R.str);
    }

    friend ostream &operator<<(ostream &L, const myString  &R);


    friend istream &operator>>(istream &L, const myString  &R);


};

//operator<<  输出运算符
ostream &operator<<(ostream &L, const myString  &R)
{
    L << R.str;
    return L;
}

//operator>>  输入运算符
istream &operator>>(istream &L, const myString  &R)
{
    L >> R.str;
    return L;
}
int main()
{

    myString mstr1 = "hello";
    myString mstr2 = "world";
    myString mstr5 = "hello";

//    cout << "len:" << mstr.str_len() << endl;
//    cout << "str:" << mstr.c_str() << endl;
//    cout << "at；"  << mstr.at(1) <<endl;

    myString mstr3;
    mstr3.operator=(mstr1);
    mstr3.show();

    myString mstr4 = mstr1.operator+(mstr2);
    mstr4.show();

    mstr1[0] = 'H';
    mstr1.show();

    cout <<mstr1.operator==(mstr5)<<endl;
    cout <<mstr1.operator!=(mstr2)<<endl;

    cout <<mstr1.operator<(mstr2)<<endl;
    cout <<mstr1.operator>(mstr2)<<endl;
    cout <<mstr1.operator<=(mstr2)<<endl;
    cout <<mstr1.operator>=(mstr2)<<endl;

    cout<<(mstr1)<<endl;
    myString mstr6;
    cin >> (mstr6);
    cout<<(mstr6);

    return 0;
}