模拟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; 就有机会修改常量对象了，不符合逻辑。