C++--String类型各种重载函数的实现

#include <iostream>
#include <string.h>
#include <string>
#include <stdio.h>



using namespace std;

class String
{
        friend bool operator == (const String &,const String &);
        friend bool operator != (const String &,const String &);
        friend bool operator <  (const String &,const String &);
        friend bool operator >  (const String &,const String &);
        friend bool operator <= (const String &,const String &);
        friend bool operator >= (const String &,const String &);

        friend ostream &operator <<(ostream &os,const String &s);
        friend istream &operator >>(istream &os,String &s);


public:
        //无参构造函数
        String()
        {
         pstr_=new char[1];
        }

        //有参构造函数
        String (const char *s)
        {
         pstr_=new char[strlen(s)+1];
         strcpy(pstr_,s);
        }


        //复制构造函数
        String (const String &rhs)
        {
          pstr_=new char[strlen(rhs.pstr_)+1];
          strcpy(pstr_,rhs.pstr_);
        }


        //赋值对象重载函数
        String &operator = (const String &rhs)
        {
         if(this!=&rhs)//如果不是自复制
         {
          delete []pstr_;//先删除掉原有的内容
          pstr_=new char[strlen(rhs.pstr_)+1];
          strcpy(pstr_,rhs.pstr_);
         }
         return *this;
        }


        //赋值字符串重载函数
        String &operator = (const char *s)
        {
         pstr_=new char[strlen(s)+1];
         strcpy(pstr_,s);
         return *this;
        }


        //重载+=运算符  左边对象本身发生了改变
        String & operator +=(const String & rhs)
        {
         //用临时的字符串指针存放
         char *tmp;
         tmp=new char[strlen(pstr_)+strlen(rhs.pstr_)+1];
         strcpy(tmp,pstr_);
         strcat(tmp,rhs.pstr_);
         delete []pstr_;
         pstr_=tmp;
         return *this;

        }
        String &operator += (const char *pstr)
        {
         char *tmp;
         tmp = new char[strlen(pstr_)+strlen(pstr)+1];//先开空间
         strcpy(tmp,pstr_);
         strcat(tmp,pstr);
         delete []pstr_;
         pstr_=tmp;
         return *this;
        }


        //重载[]下标运算符
        char &operator[](size_t index)
        {
         static char sNULL='\0';
         //要判断给出的下标越界的情况
         if(index<strlen(pstr_) && index>0)
         {
          return pstr_[index];
         }
         else
         {
          cout<<"下标越界"<<endl;
          return sNULL;
         }
        }
        //重载const对象的运算符
        const char &operator[](size_t index) const
        {
          static char sNULL='\0';
         //要判断给出的下标越界的情况
         if(index<strlen(pstr_) && index>0)
         {
          return pstr_[index];
         }
         else
         {
          cout<<"下标越界"<<endl;
          return sNULL;
         }
        }




        //返回字符串长度函数  函数后面加const代表这里面的所有变量只能读不能改
        size_t size() const
        {
          return strlen(pstr_);
        }

        //重载c_str函数  返回的是当前字符串的首字符地址
        const char* c_str()const
        {
         return pstr_;
        }




        //析构函数
        ~String()
        {
         delete []pstr_;
        }

        //打印函数
        void print()
        {
         if(pstr_==NULL)
         {
         cout<<""<<endl;
         }
        else
        {
         cout<<"string :"<<pstr_<<endl;
        }
        }

private:
        char *pstr_;

};
//重载== 函数
bool operator == (const String &lhs,const String &rhs)
{
        if(strcmp(lhs.pstr_,rhs.pstr_)==0)
        {
         return 1;
        }
        else
         {
         return 0;
         }
}
//重载!=函数
bool operator != (const String &lhs,const String &rhs)
{
        if(strcmp(lhs.pstr_,rhs.pstr_)==0)
        {
         return 0;
        }
        else
         {
         return 1;
         }
}
//重载< 函数
bool operator <(const String &lhs,const String &rhs)
{
        if(strcmp(lhs.pstr_,rhs.pstr_)<0)
        {
         return 1;
        }
        else
        {
         return 0;
        }
}
//重载>函数
bool operator >(const String &lhs,const String &rhs)
{
        if(strcmp(lhs.pstr_,rhs.pstr_)>0)
        {
         return 1;
        }
        else
        {
         return 0;
        }
}
//重载<=函数
bool operator <=(const String &lhs,const String &rhs)
{
        if(strcmp(lhs.pstr_,rhs.pstr_)<=0)
        {
         return 1;
        }
        else
        {
         return 0;
        }
}

//重载>=函数
bool operator >=(const String &lhs,const String &rhs)
{
   if(strcmp(lhs.pstr_,rhs.pstr_)>=0)
        {
         return 1;
        }
        else
        {
         return 0;
        }
}

//重载<<流
ostream &operator <<(ostream &ofs,const String &rhs)
{
        ofs<<rhs.pstr_<<endl;
        return ofs;
}
//重载>>流
istream &operator >>(istream &ifs, String &rhs)
{

        char tmp[1024];//先开空间
        ifs>>tmp;
        rhs.pstr_=tmp;//输入的字符 放到rhs中
        return ifs;

}
//重载+(两个对象之间)
String operator +(const String &lhs,const String & rhs)
{
        String str(lhs);
        str+=rhs;
        return str;
}
String operator +(const String &lhs,const char *s)
{
        String str(lhs);
        str+=s;
        return str;
}
String operator +(const char *s,const String &rhs)
{
        String str(rhs);
        str+=s;
        return s;

}


int main()
{

        String s1;//无参函数
        s1.print();

        String s2="hello";//有参函数
        s2.print();

        String s3=s2;//调用复制构造函数
        s3.print();

        String s4="world";//赋值对象重载函数
        s4=s2;
        s4.print();

        String s5; //赋值字符串重载函数
        s5="hello";
        s5.print();


        String s6="hello";//重载+=函数
        String s7="world";
        s6+=s7;
        s6.print();

        String s8="hello";//重载++函数
        s8+="world";
        s8.print();

        s8[3]='A';
        cout<<s8[3]<<endl;//重载[]运算符
        s8.print();


        String s9="hello";//重载c_str函数
        const char* s;
        s=s9.c_str();
        cout<<s<<endl;


        String s10="hello";
        if(s9==s10)       //重载==
        {
         cout<<"equal"<<endl;
        }


        String s11="world";
        if(s10!=s11)     //重载!=
        {
         cout<<"unequal"<<endl;
        }


        String s12="i am the max string";//重载<

        if(s11<s12)
        {
         cout<<"右边字符串大"<<endl;
        }
        else
        {
        cout<<"左边字符串大"<<endl;
        }
       String s13="hello";//重载<<
        cout<<s13;

        String s14;//重载>>
        cin>>s14;
        cout<<s14;

        String s15="hello";//重载+ 用到了+=
        String s16="world";
        cout<<s15+s16<<endl;


        return 0;


}