5.11作业

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

#include <iostream>
#include <cstring>

using namespace std;

class myString
{
private:
    char *str;//记录C风格的字符串
    int size;//记录字符串的实际长度
public:
    //无参构造
    myString():size(10)//构造一个长度为10的字符串
    {
        str = new char[size];
        strcpy(str,"");
    }
    //有参构造
    myString(const char *s)
    {
        size = strlen(s);
        str = new char[size+1];
        strcpy(str,s);
    }
    //拷贝构造
    myString(const myString &other):str(other.str),size(other.size)
    {
        size = other.size;
        strcpy(str,other.str);
    }
    //析构函数
    ~myString(){
        delete[] str;
    }
    //判空函数
    bool empty();
    
    //size函数
    int length();
    
     //c_str函数
    const char* c_str();
    
    //at函数
    char &at(int pos);
    
};

    //判空函数
    bool myString::empty(){
        return  0 == size;
    }
    
    //size函数
    int myString::length(){
        return size;
    }
    
    //c_str函数
    const char* myString::c_str(){
           return str;
       }
    //at函数
    char &myString::at(int pos)
    {
        char &s=str[pos];
        return s;
    }
    int &operator[](int pos)
        {
            if(pos==1)
            {
                return this->a;
            }
            else if(pos==2)
            {
                return this->b;
            }
            else
            {
                cout<<"越界"<<endl;
            }
            return this->a;
        }
        mystring &operator=(const myString &R)
        {
            this->a=R.a;
            this->b=R.b;
            return *this;
        }
        const mystring operator+(const myString &R)const
        {
            mystring temp;
            temp.a=this->a+R.a;
            temp.b=this->b+R.b;
            return temp;
        }
        bool operator==(const myString &R)const
        {
            return this->a==R.a&&this->b==R.b;
        }
        bool operator!=(const myString &R)const
        {
            return  this->a!=R.a&&this->b!=R.b;
        }
        bool operator<(const myString &R)const
        {
            return  this->a<R.a&&this->b<R.b;
        }
        bool operator>(const myString &R)const
        {
            return  this->a>R.a&&this->b>R.b;
        }
        bool operator<=(const myString &R)const
        {
            return this->a<=R.a&&this->b<=R.b;
        }
        bool operator>=(const myString &R)const
        {
            return  this->a>=R.a&&this->b>=R.b;
        }
        friend ostream &operator<<(ostream &L,const myString &R);
        friend istream &operator>>(istream &L,myString &R);
    };
    ostream &operator<<(ostream &L,const mystring &R)
    {
        if(R.b>0)
        {
            L<<R.a<<"+"<<R.b<<endl;
        }
        else
        {
            L<<R.a<<"-"<<R.b<<endl;
        }
        return L;
    }
    istream &operator>>(istream &L,mystring &R)
    {
        L>>R.a;
        L>>R.b;
        return L;
    }