c++ day4

1.完善重构函数

#include <iostream>
#include <cstring>
#include <string>

using namespace std;
class myString;
ostream& operator << (ostream& cout,const myString &s);
istream& operator >> (istream& cin,const myString &s);

class myString
{
    //protected:
public:
        char *str;          //记录c风格的字符串
        int size;            //记录字符串的实际长度
    public:
        //无参构造
        myString():size(10)
        {
            //cout<<"触发无参构造"<<endl;
            str = new char[size];         //构造出一个长度为10的字符串
            size = 0;
            strcpy(str,"");
        }
        //有参构造
        myString(const char *s)
        {
            //cout<<"触发有参构造"<<endl;

            size = strlen(s)+1;
            str = new char[size];
            strcpy(str, s);
        }

        //拷贝构造
        myString(const myString &s):str(new char[s.size+1]),size(s.size)
        {
            strcpy(str,s.str);
            //cout<<"触发拷贝函数"<<endl;
        }
        //析构函数
        ~myString()
        {
            delete []str;
            //cout<<"触发析构函数"<<endl;
        }
        //判空函数
        int empty()
        {
            if(0 == (this->size))
            {
               return 1;
            }
            else
            {
                return 0;
            }
        }
        //size函数
        int size_str()
        {
            return this->size+1;
        }
        //c_str函数
        char* c_str()
        {
            return str;
        }
        //at函数
        char &at(const int pos)
        {
            if(pos > size|| pos < 0)
            {
                cout<<"error pos"<<endl;
                return *(str+pos);

            }else
            {
                return *(str+pos);
            }

        }
        //+ 运算符重载
        const myString operator +(const myString& other)const
        {
            myString temp;
            temp.size = this->size + other.size-1;
            temp.str = new char[this->size + other.size-1];
            strcpy(temp.str,this->str);
            strcat(temp.str,other.str);
            return temp;
        }
        //= 运算符重载
        myString &operator =(const myString& other)
        {
            if(this != &other)
            {
                delete []this->str;
                new char[other.size];
                strcpy(str,other.str);
                this->size = other.size;
            }
            //cout<<"触发=重载"<<endl;
            return *this;
        }
        //+= 运算符重载
        myString &operator +=(const myString& other)
        {
            //如果是相加自己就需要cat两次str
            if(this == &other)
            {
                char *str = new char[this->size+1];
                memset(str,0,this->size+1);
                strcpy(str,this->str);
                //删除字符串this->str并重构this->str和修改this->size
                delete [] this->str;
                this->str = new char[other.size+this->size-1];
                strcpy(this->str,str);
                strcat(this->str,str);
                this->size = other.size+this->size-1;
                //删去中间字符串str
                delete []str;
                return *this;
            }
            else
            {
                //如果是加不同的字符串只需要加一次str一次other.str
                //拷贝原字符串
                char *str = new char[this->size+1];
                memset(str,0,this->size+1);
                strcpy(str,this->str);
                //删除字符串this->str并重构this->str和修改this->size
                delete [] this->str;
                this->str = new char[other.size+this->size-1];
                strcpy(this->str,str);
                strcat(this->str,other.str);
                this->size = other.size+this->size-1;
                //删去中间字符串str
                delete []str;
                return *this;
            }
        }
        //==运算符重载
         bool  operator ==(const  myString& other)const
        {
            if(0 == strcmp(this->str,other.str))
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
         //>=运算符重载
         bool  operator >= (const  myString& other)const
        {
            if((0 == strcmp(this->str,other.str))&&(0 < strcmp(this->str,other.str)))
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
         //<=运算符重载
         bool  operator <=(const  myString& other)const
        {
            if((0 == strcmp(this->str,other.str))&&(0 > strcmp(this->str,other.str)))
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
         //>运算符重载
        bool  operator > (const  myString& other)const
        {
            if(0 < strcmp(this->str,other.str))
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
        //<运算符重载
        bool  operator < (const  myString& other)const
        {
            if(0 > strcmp(this->str,other.str))
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
        //！=运算符重载
        bool  operator != (const  myString& other)const
        {
            if(0 != strcmp(this->str,other.str))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        //[]运算符重载
        char operator [](int pos)
        {
            if(pos > size|| pos < 0)
            {
                cout<<"error pos"<<endl;
                return *(str+pos);

            }else
            {
                return *(str+pos);
            }
        }
        //友元cout类型
        friend ostream& operator << (ostream& cout,const myString &s);
        //友元cin类型
        friend istream& operator >> (istream& cin,const myString &s);
};
ostream& operator << (ostream& cout,const myString &s)
{
    cout<<s.str<<endl;
    cout<<s.size<<endl;
    return  cout;
}
istream& operator >> (istream& cin, myString &s)
{
    //创建一个新的字符串
    string str;
    cout<<"请输入字符串"<<endl;
    cin>>str;
    //释放最初的字符空间
    delete [] s.str;
    //开辟新的字符空间大小和新的一致并初始化

    memset(s.str,0,s.size);
    //拷贝str和修改str
    strcpy(s.str,str.c_str());
    s.size = str.size();
    return  cin;
}
int main()
{
    //无参构造
    myString d;
    cout<<"d.empty = "<<d.empty()<<endl;

    //初始化s
    myString s("asdwqe");
    cout<<s.size<<endl;
    cout<<s<<endl;
    //初始化 b
    myString b(s);
    //打印b
    cout<<"b = "<<b.c_str()<<endl;
    //打印b的长度
    cout<<"s.size_str = "<<s.size_str()<<endl;
    //判断s是否为空0为非空1为空
    cout<<"s.empty = "<<s.empty()<<endl;
    //修改第五位值
    s.at(5) = 'B';
    cout<<"s(5) = "<<s.at(5)<<endl;
    //给s copy新值
    strcpy(s.c_str(),"dsaqweqwe");
    cout<<"s.c_str = "<<s.c_str()<<endl;
    //测试超出范围的报错
    s.at(100);
    //等号测试
    d = s;
    cout<<"d = "<<d.c_str()<<endl;
    //[]运算符测试
    cout<<"d[5] = "<<d[5]<<endl;
    //测试大小判断
    cout<<"(d = s) = "<<(d == s)<<endl;
    cout<<"(d > s) = "<<(d > s)<<endl;
    cout<<"(b >= s) = "<<(d >= s)<<endl;
    cout<<"(b < s) = "<<(d < s)<<endl;

    //cout重载
    cout<<"d.str = "<<d<<endl;
    //cin重载
    cin>>d;
    cout<<"d.str = "<<d<<endl;
    //+=前s
    cout<<"s.str"<<endl;
    cout<<s<<endl;
     //+=后s
    cout<<"(s+=s)"<<endl;
    cout<<(s+=s)<<endl;

    cout<<(s+s).str<<endl;
    return 0;
}