C++在myString的基础上，重载运算符（2023-3-29）

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

//定义类
class myString{
private:
    //用来存储传进来的字符串
    char *str;
    //记录长度
    int size;
public:
    //无参构造用于给对象申请空间
    myString():size(10)
    {
        str =  new char[size];
        cout << "无参构造" << endl;
    }

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

        cout << "有参构造" << endl;
    }

    //拷贝构造
    myString(const myString & other)
    {
        size = other.size;
        str = new char[size + 1];
        strcpy(str, other.str);

        cout << "拷贝构造" << endl;
    }

    //拷贝赋值
    myString &operator= (const myString &other)
    {
        if(this == &other)
        {
            return *this;
        }
        delete []str;
        size = other.size;
        str = new char[size+1];
        strcpy(str, other.str);

        return *this;

        cout << "拷贝赋值" << endl;
    }

    //析构函数
    ~myString()
    {
        delete []str;

        cout << "析构函数" << endl;
    }

    //判空函数
    bool empty()
    {
        if(strlen(str) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    //size函数
    int length()
    {
        return size;
    }

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

    //at函数
    char &at(int pos)
    {
        if(pos >= size || pos < 0)
        {
            cout << "段错误" << endl;
        }
        return str[pos];
    }

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

    //实现+运算符重载
    const myString operator+(const myString &other)const
    {
        myString temp;
        delete []temp.str;
        temp.size=size+other.size;
        temp.str=new char(temp.size+1);
        strcpy(temp.str,str);
        temp.str=strcat(temp.str,other.str);
        return temp;
    }
    //实现+=重载
    const myString &operator+=(const myString &R)
    {
        strcat(this->str,R.str);
        this->size = strlen(this->str);
        return *this;
    }

    //实现[]重载
    char &operator[](int n)
    {
        if(n<0||n>size)
        {
            cout<<"越界"<<endl;
        }
        else
            return str[n-1];
    }
    //实现>运算符重载
    bool operator>(const myString &other)const
    {
        return strcmp(str,other.str)>0;
    }

    //实现==运算符重载
    bool operator==(const myString &other)const
    {
        return strcmp(str,other.str)==0;
    }

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

//全局变量完成<<运算的重载
ostream &operator<<(ostream &L,myString &R)
{
    L<<R.str<<endl;
    return L;
}


int main()
{
    //有参构造函数
    myString s1("hello");
    cout << "s1 = " << s1.c_str() << endl;
    //拷贝构造函数
    myString s2(s1);
    cout << "s2 = " << s2.c_str() << endl;

    myString s3;
    //拷贝赋值函数
    if(!s3.empty())
    {
        //对等号进行更改了
        s3 = s2;
    }
    cout << "s3.length() = " << s3.length() << endl;
    cout << "s3.c_str() = " << s3.c_str() << endl;
    cout << "s3.at(3) = " << s3.at(3) << endl;

    myString s4("world");
    myString s5;
    //重载+
    s5=s1+s4;
    cout<<"重载实现+运算符："<<endl;
    s5.show();
    //重载+=
    cout<<"重载实现+=："<<endl;
    s1+=s2;
    cout<<"s1="<<s1<<endl;
    //重载[]
    cout<<"重载实现[]："<<endl;
    cout<<"s5[8]="<<s5[8]<<endl;

    //重载>、==
    if(s1==s2)
    {
        cout<<"s1=s2"<<endl;
    }
    else if(s1>s2)
    {
        cout<<"s1>s2"<<endl;
    }

    //重载<<
    cout<<"重载<<:"<<endl;
    cout<<s5<<endl;
    return 0;
}