4.22 C++作业

实现string类的各个运算符重载

#include <iostream>
#include <cstring>

using namespace std;


//string类的功能是给定一个
class myString
{
private:
    char *str;//用于指向堆区申请空间的首地址
    int size;//用于存储申请的空间大小

public:
    //无参构造
    myString():size(32) //参构造需要初始化列表 来给成员初始化
    {
        //下列是申请的操作
        str=new char[size];
        strcpy(str,"");//调用无参构造后，在堆区申请一片空间，将内容赋值为空
    }

    //有参构造
    myString(const char *s)//有参构造的参数s用于给申请的堆区空间中赋值，并申请对应大小的空间
    {
        size=strlen(s);
        str=new char[size+1];
        strcpy(str,s);
    }

    //拷贝构造函数,需要使用列表
    myString(const myString &other):str(new char[other.size+1]),size(other.size)
    {
         strcpy(str,other.str);
    }

    //祈构函数
    ~myString()
    {
        delete []str;
        str=nullptr;
        cout<<"myString::析构函数"<<endl;
    }

    //判空函数
    int myempty()
    {
        if(strlen(str))
        {
            return 0;
        }
        else
        {
            return 1;
        }
    }


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

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

    //at函数
    char &my_at(int pos)
    {
        return str[pos];
    }

    //拷贝赋值函数
    myString &operator=(const myString &other)
    {
        if(this != &other)
        {

            this->size = other.size;//复制大小
            this->str=new char[this->size+1];

            strcpy(this->str,other.str); //字符串赋值到空间中
            cout<<"拷贝复制函数"<<endl;
        }
        return *this;
    }

    //重载[]符
    char operator[](int pos)//返回值什么时候使用类名什么时候时候使用别的类型
    {
        if(pos>size||pos<0)
        {
            cout<<"下标位置不存在"<<endl;
        }
        else
        {
            return this->str[pos];
        }

    }

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

    //重载==号运算符
     bool operator==(const myString &s)const
     {
         if(strcmp(this->str,s.str)==0)
         {
             return 1;
         }
         else
         {
             return 0;
         }
     }

     //重载 > 号运算符
     bool operator>(const myString &s)const
     {
         if(strcmp(this->str,s.str)>0)
         {
             return 1;
         }
         else
         {
             return 0;
         }
     }

     //重载 < 号运算符
     bool operator<(const myString &s)const
     {
         if(strcmp(this->str,s.str)<0)
         {
             return 1;
         }
         else
         {
             return 0;
         }
     }
     friend ostream &operator << (ostream &cout,const myString &s);
     friend istream &operator >> (istream &cin,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;
    cin>>str;

    delete []s.str;
    memset(s.str,0,s.size);
    strcpy(s.str,str.c_str());
    s.size = str.size();

    return cin;
}

int main()
{

   myString s1("hello world"); //s1调用有参构造

   myString s2=s1;  //s2调用拷贝构造函数

   //使用len函数
   cout<<"s2 = "<<s2.len()<<endl;


   myString s3;

   //使用判空
   if(s3.myempty())
   {
         cout<<"empty"<<endl;
   }
   else
   {
         cout<<"not empty"<<endl;
   }

   //使用c_str
   char buf[]="ni hao";
   myString s4=s1;
   strcpy(buf,s4.my_c_str());
   cout<<buf<<endl;

   //使用at函数
      s4.my_at(4)='B';
      cout<<s4.my_c_str()<<endl;//打印s2中的值

   //使用重载[]运算符
   cout<<"s1[3]="<<s1[3]<<endl;

   //使用关系运算符
   if(s1==s2)
   {
       cout<<"s1==s2"<<endl;
   }
   else if(s1>s2)
   {
       cout<<"s1>s2"<<endl;
   }
   else if(s1<s2)
   {
       cout<<"s1<s2"<<endl;
   }
   else
   {
       cout<<"error "<<endl;
   }

   //使用+运算符
    cout<<"s1+s2  "<<s1+s2<<endl;

    return 0;
}