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 charchar *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_);
}
returnreturn *this;
}

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

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

}
String &operator += (const charchar *pstr)
{
charchar *tmp;
tmp = new char[strlen(pstr_)+strlen(pstr)+1];//先开空间
strcpy(tmp,pstr_);
strcat(tmp,pstr);
delete []pstr_;
pstr_=tmp;
returnreturn *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:
charchar *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 charchar *s)
{
String str(lhs);
str+=s;
return str;
}
String operator +(const charchar *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;

}