#include<iostream>
#include<cstring>
#include<cassert>
#include<iomanip>

using namespace std;
class String;
istream& operator>>(istream&, String&);
ostream& operator<<(ostream&,const String&);

class String
{
public:
 //构造函数
 //String s1();
 //String s1("abc");
 //String s2(s1);
 String();
 String(const char*);
 String(const String&);
 //析构函数
 ~String();
 //赋值操作
 String& operator=(const char*);
 String& operator=(const String&);
 //等于操作
 bool operator==(const char*);
 bool operator==(const String&);
 //加操作
 String operator+(const String&) const;
 //下标操作
 char& operator[](int);
 //成员操作
 int size(){return _size;}
 char* c_str(){return _string;}
 //记数操作
 int count(const char) const;
private:
 int  _size;
 char *_string;
};

inline String::String()                                    //构造函数
{
 _size=0;
 _string=0;
}

inline String::String(const char* str)                     //构造函数
{
 if(!str)
 {
  _size=0;
  _string=0;
 }
 else
 {
  _size=strlen(str);
  _string=new char[_size+1];
  strcpy(_string,str);
 }
}

inline String::String(const String& str)                  //拷贝构造函数
{
 if(!str._size)
 {
  _size=0;
  _string=0;
 }
 else
 {
  _size=strlen(str._string);
  _string=new char[_size+1];
  strcpy(_string,str._string);
 }
}

inline String::~String()                                  //析构函数
{
 delete[] _string;
}

inline String& String::operator=(const char* str)         //赋值操作
{
 if(!str)
 {
  _size=0;
  delete[] _string;
  _string=0;
 }
 else
 {
  _size=strlen(str);
  delete[] _string;
  _string=new char[_size+1];
  strcpy(_string,str);
 }
 return *this;
}

inline String& String::operator=(const String &str)      //赋值操作
{
 if(this!=&str)
 {
  _size=str._size;
  delete[] _string;
  _string=new char[_size+1];
  strcpy(_string,str._string);
 }
 return *this;
}

inline bool String::operator==(const String &rhs)          //等于操作符重载
{
 if(_size!=rhs._size)
  return false;
 return strcmp(_string,rhs._string)?false:true;
}

inline bool String::operator==(const char *str)            //等于操作符重载
{
 return strcmp(_string,str)?false:true;
}

inline char& String::operator[](int n)                     //下标访问符
{
 assert(n>=0 && n<_size);
 return _string[n];
}

inline int String::count(const char s) const               //记数操作
{
 int tempCount=0;
 for(int i=0;i<_size;i++)
 {
     if(_string[i]==s)
   ++tempCount;
 }
 return tempCount;
}

inline String String::operator+(const String& str) const  //加操作
{
 String tempStr;
 tempStr._size=_size+str._size;
 tempStr._string=new char[tempStr._size+1];
 strcpy(tempStr._string,_string);
 strcat(tempStr._string,str._string);
 return tempStr;
}

inline istream& operator>>(istream &io,String &str)       //输入流
{
 const int limit_string_size =4096;
 char inBuf[limit_string_size];
 io>>setw(limit_string_size)>>inBuf;
 str=inBuf;
 return io;
}

inline ostream& operator<<(ostream &os,String &str)       //输出流
{
 return os<<str.c_str();
}

int main()
{
 String str1="abc";
 String str2="def";
 str1.size();
 cout<<"size :"<<str1.size()<<endl;
 cout<<"b count :"<<str1.count('b')<<endl;
 String str3=str1+str2;
 cout<<str3;      //该处不能为String&，只能为String。见String operator+()和ostream& operator<<(ostream &os,String &str)
 return 0;
}

SO GOOD!