class String
{
 public:
  String()
  {
   data = new char[1];  //这里为什么使用new char[1]呢，虽然是一个字符，这是为了和析构函数保持对称，因为在别的构造函数中使用的char[]
   data[0]='\0';
   length = 0;
  }
  String(const char* str)
  {
   length = strlen(str);
   data = new char[length+1];
   strcpy(data,str);
   data[length]='\0';
  }
  String(const char* str,int n)
  {
   length = n;
   data = new char[n+1];
   strncpy(data,str,n);
   data[length] ='\0';
  }
  String(const String& src) //拷贝构造函数 也就是复制构造函数
  {
   length = src.length;
   data = new char[length+1];
   strcpy(data,src.data);
  }
  String& operator=(const String& src) //赋值构造函数
  {
   if(this == &src)
    return *this;
   delete [] data;
   data = new char[src.length+1];
   strcpy(data,src.data);
   return *this;
  }
  String& operator=(const char* src) //另一种的赋值构造函数
  {
   delete [] data;
   length = strlen(src);
   data = new char[length+1];
   strcpy(data,src);
   return *this;
  }
  char& operator[](int n)
  {
   return data[n];
  }
  const char& operator[](int n) const  //对于const成员函数 最好就是返回const的引用，这样是为了避免返回值被修改
  {
   return data[n];
  }
 friend ostream& operator<<(ostream& os,const String& st)； 
   
  ~String()
  {
   delete [] data; 
  }
 private:
  char* data;
  int length; 
};
ostream& operator<<(ostream& os,const String& st)
{
   os<<st.data;
  return os;
}