模拟string类

做为学习重载的最佳练习，自己写了这个string类，请大家指正！

// string.h
#ifndef MyString_H
#define  MyString_H
#include  < iostream >
using   namespace  std;

class  MyString ... {
private:
  char *data;
  int length;
public:
  MyString();
  ~MyString();                //destructor

  MyString(const char *str); //constructor
  MyString(const MyString& str);
  
  int getLength() const;
  //overloading
  const MyString& operator=(const char *str); //str = "a"
  const MyString& operator=(const MyString& str); //str1 = str2

  char& operator[](int i); // str[i] = n
  const char& operator[](int i) const; // const str, char m = str[i];

  MyString& operator+=(const char *str); // str += "a", str += "b"
  MyString& operator+=(const MyString& str); // str1 += str2, str1 += str3

  bool operator!() const; //judge whether is empty
  bool operator==(const char *str) const; // str1 == "a"
  bool operator==(const MyString& str) const; // str1 == str2

  bool operator!=(const char *str) const; // str1 != "a"
  bool operator!=(const MyString& str) const; // str1 != str2
  
  bool operator<(const char *str) const; // str1 < "a"
  bool operator<(const MyString& str) const; // str1 < str2

  bool operator>(const char *str) const; // str1 > "a"
  bool operator>(const MyString& str) const; // str1 > str2

  bool operator<=(const char *str) const; // str1 <= "a"
  bool operator<=(const MyString& str) const; // str1 <= str2

  bool operator>=(const char *str) const; // str1 >= "a"
  bool operator>=(const MyString& str) const; // str1 >= str2
public:
  friend ostream& operator<<(ostream& output, const MyString& str);
  friend istream& operator>>(istream& input, MyString& str);
} ;
#endif

// string.cpp
#include  " string.h "
#include  < assert.h >

MyString::MyString( const   char   * str) ... {
  length = strlen(str);
  data = new char[length+1];
  strcpy(data,str);
}

MyString::MyString( const  MyString &  str) ... {
  length = str.length;
  data = new char[length+1];
  strcpy(data,str.data);
}

MyString::MyString() ... {
  data = NULL;
  length = 0;
}
MyString:: ~ MyString() ... {
  delete[] data;
}

int  MyString::getLength()  const ... {
  return length;
}

const  MyString &  MyString:: operator = ( const   char   * str) ... {
  length = strlen(str);
  delete[] data;
  data = new char[length+1];
  strcpy(data, str);
  return *this;
}

const  MyString &  MyString:: operator = ( const  MyString &  str) ... {
  if(this != &str)...{
    delete[] data;
    length = str.length;
    data = new char[length+1];
    strcpy(data, str.data);
  }
  return *this;
}

char &  MyString:: operator []( int  i) ... {
  assert(i>0 && i < length);
  return data[i];
}

const   char &  MyString:: operator []( int  i)  const ... {
  assert(i > 0 && i < length);
  return data[i];
}

MyString &  MyString:: operator += ( const   char   * str) ... {
  int len = length + strlen(str);
  char *tempdata = new char[len+1];
  strcpy(tempdata, data); // copy self to new place
  strcpy(tempdata+length, str); // copy str
  delete[] data;
  data = tempdata;
  length = len;
  return *this;
}  


MyString &  MyString:: operator += ( const  MyString &  str) ... {
  int len = length + str.length;
  char *tempdata = new char[len+1];
  strcpy(tempdata, data);
  strcpy(tempdata+length, str.data);
  delete[] data;
  data = tempdata;
  length = len;
  return *this;
}

bool  MyString:: operator ! ()  const ... {
  return length == 0;
}

bool  MyString:: operator == ( const   char   * str)  const ... {
  return strcmp(data,str) == 0;
}

bool  MyString:: operator == ( const  MyString &  str)  const ... {
  return strcmp(data,str.data) == 0;
}

bool  MyString:: operator != ( const   char   * str)  const ... {
  return !(*this == str);
}

bool  MyString:: operator != ( const  MyString &  str)  const ... {
  return !(this == &str);
}

bool  MyString:: operator < ( const   char   * str)  const ... {
  return strcmp(data, str) < 0;
}

bool  MyString:: operator < ( const  MyString &  str)  const ... {
  return strcmp(data,str.data) < 0;
}

bool  MyString:: operator > ( const   char   * str)  const ... {
  return strcmp(data, str) > 0;
}

bool  MyString:: operator > ( const  MyString &  str)  const ... {
  return strcmp(data, str.data) > 0;
}

bool  MyString:: operator <= ( const   char   * str)  const ... {
  return !(*this > str);
}

bool  MyString:: operator <= ( const  MyString &  str)  const ... {
  return !(*this > str);
}

bool  MyString:: operator >= ( const   char   * str)  const ... {
  return !(*this < str);
}

bool  MyString:: operator >= ( const  MyString &  str)  const ... {
  return !(*this < str);
}

ostream &   operator << (ostream &  output,  const  MyString &  str) ... {
  output << str.data;
  return output;
}

istream &   operator >> (istream &  input, MyString &  str) ... {
  char temp[1024];
  input >> temp;
  str = temp;
  return input;
}

P.S: 在自己动手写之前，参考过别人写的代码，对

const char& operator[](int i) const; 

没想明白，因为无论是 str[i]=c 或 c = str[i]都是调用的非const的形式，至于带const什么时候调用，心里有疑惑。网上搜了一圈，恍然大悟!

举个例子：

Mystring str("hello");

str[1]='m'

char c = str[1]

这两处都是调用非const修饰的成员函数，可是如果定义

const Mystring str("world");

char c = str[1];

str[1] = 'n'----这里将出现编译错误：C2166: l-value specifies const object

为什么呢？因为对象是const，所以呢会调用const修饰的重载函数，但由于其返回值为const，所以返回值就不能被修改，符合逻辑。

如果返回值不是const，即如果是 char& operator[](int i) const; 就有机会修改常量对象了，不符合逻辑。