通过重载类的成员操作符来实现对string 类的模拟

 /*本程序通过重载类的成员操作符来实现对string 类的模拟*/
#include<iostream>
#include<cassert>
#include<fstream>
using namespace std;
class String;
ostream &operator <<(ostream &, String &);
istream &operator >>(istream &, String &);
class String
{
 friend ostream &operator <<(ostream &, String &);
 friend istream &operator >>(istream &, String &);
public:
 String():_String(0),_size(0)
 {cout<<"构造函数1被调用"<<endl;} //构造函数1
 String(char *p):_size(strlen(p))//构造函数2
 {
  _String=new char(_size+1);
  strcpy(_String,p);
 }

 String(const String & p);//拷贝构造函数
 String &operator=(const String &p);//对赋值操作符=的重载1
 String &operator=(char *p);//对赋值操作符=的重载2
 String &operator+=(String &p);//对+=操作符的重载1
 String &operator+=(char *p);//对+=操作符的重载2
 char &operator [](int x) const;//对下标操作符的重载，必须返回一个左值，因为她
 //即可以出现在赋值表达式的左边，也可以出现在赋值表达式的右边
 bool operator==( String &p);//对等于操作符的重载1
    bool operator==(char *p);//对等于操作符的重载2
 ~String()
 {
  delete []_String;
  cout<<"析构函数被调用"<<endl;
 }

private:
 int _size;
 char *_String;
};

inline String::String(const String &p)
{  
 if(p._size!=0)
 {
 _size=p._size;
 _String=new char[_size+1];
 strcpy(_String,p._String);
 }
 else
 {
  _size=0;
  _String=0;
 }
}

inline String &String::operator=(const String &p)
{   if(_String)
 delete _String;
 _size=p._size ;
 if(p._size )
 {
  _String=new char [_size+1];
  strcpy(_String,p._String );
 }
 else
  _String=0;
 return *this;
}

inline String &String::operator=(char *p)
{
 delete _String;
 _size=strlen(p);
 if(_size)
 {
  _String=new char [_size+1];
     strcmp(_String,p);
 }
 else
  _String=0;
 return *this;
}

inline String &String::operator+=(String &p)
{
 if(p._size )
 {
  String tmp(*this);
  _size+=p._size ;
  delete _String;
  _String =new char[_size+1];
  strcpy(_String,tmp._String );
  strcpy(_String+tmp._size,p._String );
 }
 return *this;
}

inline String &String::operator+=(char *p)
{
 if(p)
 {
  String tmp(*this);
  _size+=strlen(p);
  delete _String;
  _String=new char [_size+1];
  strcpy(_String,tmp._String);
  strcpy(_String+tmp._size,p);
 }
 return *this;
}

inline char &String::operator[](int x)const
{
 assert(x>=0&&x<_size);
 return  _String[x];
}

inline bool String::operator==(String &p)
{
 if(_size!=p._size )
  return false;
 return (strcmp(_String,p._String )? false :true);
}

inline bool String::operator==(char *p)
{
 _size=strlen(p);
 if(_size)
  return false;
 return (strcmp(_String,p)?false:true);
}

 

 ostream &operator<<(ostream &output, String &p)
 { 
 output<<p._String ;
 return output;
}
 istream &operator>>(istream &input, String &p)
 {
    char q[100]; 
 input>>q;
 p._size =strlen(q);
 p._String=new char[p._size+1];
 strcpy(p._String,q);
 return input;
}

 

void main()
{ 
 String s1,s2,s3;
 cout<<"请连续输入两个字符串"<<endl;
    cin>>s1>>s2;

 cout<<"s1=s2?"<<endl;
 if(s1==s2)
  cout<<"等于"<<endl;
 else cout<<"不等于"<<endl;

 s1+=s2;
 cout<<"相加后的s1的值为"<<s1<<endl;
}

 /*错误一： 出现说不能在函数中调用类的私有数据成员，知道是友元的声明有问题，
 后来发现是由于在类String的前面要先有
 ostream &operator <<(ostream &, String &);和
istream &operator >>(istream &, String &);的声明，才能在类里面加上
friend ostream &operator <<(ostream &, String &);和
friend istream &operator >>(istream &, String &);
因为这两个友元是在类的定义之后定义的，但是又因为类前对友元的声明涉及到类，所以又得在
友元的声明之前加上类的声明：calss String;
  错误二：现在编译没有问题了，但是程序运行时有突然终止。错误根源在于对>>操作符的
  定义是完全错误的，因为s1和s2是调用缺省的构造函数，所以它们的_String的指针所指
  的内存是空的，而我直接：input>>P._String; p._size=strlen(P._String);怎么不会出现
  内存错误呢，p._String连内存都没有分配，怎么接受输入呢。所以要定义一个暂时的char q
  [100]来缓存输入数据。char q[100]; 
 input>>q;
 p._size =strlen(q);
 p._String=new char[p._size+1];
 strcpy(p._String,q);
 return input;
 但是这有个局限，就是跟q这个字符数组的大小有关，如果输入
 的字符串大于100，那就又会出错了，可能还有其他的好的方法
*/