C++day4

1、仿照string类，完成myString 类

#include <iostream>
#include <cstring>

using namespace std;
class myString
{
    private:
        char *str;          //记录c风格的字符串
        int size;            //记录字符串的实际长度
    public:
        //无参构造
        myString():size(10)
        {
            str = new char[size];         //构造出一个长度为10的字符串
            strcpy(str,"");         //赋值为空串
        }
        //有参构造
        myString(const char *s)          //string  s("hello world")
        {
            size = strlen(s);
            str = new char[size+1];
            strcpy(str, s);
        }

        //拷贝构造
        myString(const myString &other):str(new char(*other.str)),size(other.size)
        {
            cout<<"拷贝构造函数"<<endl;
        }
        //析构函数
        ~myString()
        {
            delete str;
            cout<<"myString::析构函数:"<<this<<endl;
        }
        //拷贝赋值函数
        myString & operator=(const myString &other)
        {
            if(this != &other)
            {
                this->size = other.size;

                //判断原来的指针空间是否被清空
                if(this->str != NULL)
                {
                    delete this->str;
                }
                this->str = new char(*other.str);
            }

            cout<<"myString::拷贝赋值函数"<<endl;
            return *this;
        }
        //判空函数
    bool my_empty()
    {
        if(0 == get_size())
        {
            return true;
        }

        return false;
    }
        //size函数
    int get_size()
    {
        size=0;
        while(*str != 0)
        {
            str++;
            size++;
        }
        return size;
    }
        //c_str函数
    char *c_str()
    {
        return this->str;
    }

        //at函数
        char &at(int pos)
        {
            if(pos >= 0 && pos< size)
            {
                return this->str[pos];
            }
            else
            {
                cout<<"数组越界"<<endl;
            }
        }



        //加号运算符重载
    const myString operator+ (const myString &R)const
    {

        myString c;

        c.str=strcat(this->str, R.str);

        return c;

    }
        //加等于运算符重载

       myString operator+= (const myString &R)
       {
           //this->str = new char[this->size+R.size+1];
           strcat(this->str,R.str);
           this->size+=R.size;

           return *this;
       }

        //关系运算符重载（>）
    bool operator> (const myString &R)const
    {
        if(strcmp(this->str,R.str) > 0)
        {
            return true;
        }
        else
        return false;
    }
        //中括号运算符重载
    char & operator[](int i)
    {
        if(i >= 0 && i< size)
        {
            return this->str[i];
        }
        else
        {
            cout<<"数组越界"<<endl;
        }
    }



    void display()
    {
        cout<<this->str<<endl;
    }
};
int main()
{
    myString ptr("hello");
    myString ptr2("world");
    myString ptr3 = ptr+ptr2;
    ptr3.display();
    cout<<ptr.at(1)<<endl;
    cout<<ptr[1]<<endl;
    ptr+=ptr2;
    ptr.display();

    return 0;
}