DAY65

作业：

将myString类中能够实现的操作都实现一遍

#include <iostream>
#include <cstring>

using namespace std;

//定义一个复数类：有实部和虚部组成的一个数据： a+bi
class Mystring
{
private:
    char *str;
    int size;

public:
    Mystring():size(10){};    //无参
    Mystring(char* s)  //有参
    {
        size = sizeof(s);
        str = new char[size+1];
        strcpy(str,s);
    }
    ~Mystring()
    {
        delete(str);
    }

    //size函数
    int len()
    {
        return strlen(str);
    }



    //二倍扩容
    void kr()
    {
        char* str1;
        str1= new char[size*2+1];
        strcpy(str1,str);
        str = str1;
        size = size*2;
    }

    //定义输出函数
    void show()
    {
        if(size > 0)
        {
            cout<<str<<endl;
        }
    }

    //定义成员函数版完成字符串的赋值运算：
    const Mystring operator=(const Mystring &R)const
    {
        strcpy(this->str,R.str);
        return *this;
    }

    //at函数
    char &at(int index)
    {
        if(size<=0)
        {
            cout<<"字符串为空"<<endl;
        }
        return str[index-1];
    }

    //定义成员函数版完成字符串的访问：
    char &operator[](int n)
    {
        return str[n-1];
    }

    char* data()
    {
        return str;
    }

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

    //判空函数
    bool emtpy()
    {
        return size;
    }

    int capacity()
    {
        return size;
    }

    //清空内容
    void clear()
    {
        delete(str);
        str = new char[10];
    }

    //后附字符到结尾
    void append(char* s)
    {
        int num = strlen(str) + strlen(s);
        if(num > size)
        {
            kr();
        }
        strcat(str,s);
    }

    //成员函数版完成+=运算符重载
    Mystring &operator+=(const Mystring &R)
    {
        strcat(this->str,R.str);

        return *this;
    }

    //定义成员函数版完成字符串的+运算：
    const Mystring operator+(const Mystring &R)const
    {
        strcat(this->str,R.str);
        return *this;
    }

    //定义成员函数版完成关系运算符重载：
    bool operator>(const Mystring &R)const
    {
        if(strcmp(this->str,R.str)>0)
        {
            return true;
        }else
        {
            return false;
        }
    }

    bool operator<(const Mystring &R)const
    {
        if(strcmp(this->str,R.str)<0)
        {
            return true;
        }else
        {
            return false;
        }
    }

    bool operator==(const Mystring &R)const
    {
        if(strcmp(this->str,R.str)==0)
        {
            return true;
        }else
        {
            return false;
        }
    }

    bool operator>=(const Mystring &R)const
    {
        if(strcmp(this->str,R.str)>=0)
        {
            return true;
        }else
        {
            return false;
        }
    }

    bool operator<=(const Mystring &R)const
    {
        if(strcmp(this->str,R.str)<=0)
        {
            return true;
        }else
        {
            return false;
        }
    }

    //定义友元
    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)
{
    L>>R.str;

    //返回左操作
    return L;
}


int main()
{


    return 0;
}