c++ STL string类仿写

最近看string类成员函数的时候，想着自己实现一下类似的字符串类。写了下，大体上粗略的实现了
常见的函数，运算符等。有些函数没写重载形式了。主要是封装一个char* 指针，对其作操作.现在想想应该把增大容量的操作封装成一个函数调用，不用每次都实现。。。
我是一个小菜鸟，如有错误多多指出。代码如下：

#include <iostream>
#include <cstring>
using namespace std;

class MyString{
public:
class Iterator{
public:
Iterator(MyString& ms):_ms(ms),_index(0){}
Iterator(MyString& ms,int index):_ms(ms),_index(index){}
Iterator(const Iterator& it):_ms(it._ms),_index(it._index){}
~Iterator(){}

char& operator*(){return _ms[_index];}
bool operator==(Iterator it){return _ms==it._ms&&_index==it._index;}
bool operator!=(Iterator it){return !(_ms==it._ms&&_index==it._index);}
Iterator operator++(){++_index;return *this;}
Iterator operator+(int offset){Iterator it(_ms,_index+offset);return it;}
Iterator operator++(int){Iterator it(_ms,_index);++_index;return it;}

private:
int _index;
MyString& _ms;
};

public:
MyString();
~MyString();
MyString(const MyString& ms);
MyString(const char* s);
MyString(int n,char c);
int length(){return _length;}
int size(){return _length;}
void clear();
bool empty(){return _length==0;}
char& back(){return *_data;}
char& front(){return *(_data+_length-1);}
const char* data(){return _data;};
const char* c_str(){return _data;}
int capacity(){return _capacity;}
char& at(int);
char& at(int)const;
MyString& append(const MyString&);
MyString& insert(int index,const MyString&);
MyString& earse(int index,int len);
void swap(MyString&);
MyString substr(int index,int len);
void reverse();
Iterator begin();
Iterator end();

char& operator[](int index);
MyString operator+(MyString&);
void operator+=(MyString&);
void operator+=(const char*);
void operator=(const char*);
void operator=(const MyString&);

friend ostream& operator<<(ostream&,MyString&);
friend istream& operator>>(istream&,MyString&);
friend bool operator==(MyString&,MyString&);
friend void swap(MyString&,MyString&);

private:
char *_data;
int _length;
int _capacity;
};

MyString::Iterator MyString::begin(){
Iterator it(*this);
return it;
}

MyString::Iterator MyString::end(){
Iterator it(*this,_length);
return it;
}

ostream& operator<<(ostream& out,MyString& ms){
out<<ms._data;
return out;
}

istream& operator>>(istream& in,MyString& ms){
char buffer[1024];
in>>buffer;
ms._length=strlen(buffer);
if(ms._capacity>ms._length){
strcpy(ms._data,buffer);
}
else{
while(ms._capacity<ms._length)ms._capacity*=2;
delete ms._data;
ms._data=new char[ms._capacity];
strcpy(ms._data,buffer);
}

return in;
}

void swap(MyString& ms1,MyString& ms2){
ms1.swap(ms2);
}

bool operator==(MyString& ms1,MyString& ms2){
if(strcmp(ms1._data,ms2._data)==0)
return true;
return false;
}

void MyString::reverse(){
char tmp;
for(int i=0;i<_length/2;i++){
tmp=_data[i];
_data[i]=_data[_length-1-i];
_data[_length-i-1]=tmp;
}
}

MyString MyString::substr(int index,int len){
if(index<0 || index>=_length)return *this;
if(index+len>_length)len=_length-index;

char *tmp=new char[len+1];
for(int i=index,j=0;i<index+len;i++){
tmp[j++]=_data[i];
}
tmp[len]='\0';

MyString ms(tmp);
delete tmp;

return ms;
}

void MyString::swap(MyString& ms){
int t=_length;
_length=ms._length;
ms._length=t;

t=_capacity;
_capacity=ms._capacity;
ms._capacity=t;

char *p=_data;
_data=ms._data;
ms._data=p;
}

MyString& MyString::earse(int index,int len){
if(index<0 || index>=_length)return *this;
if(index+len>_length)len=_length-index;

for(int i=index+len;i<=_length;i++){
_data[i-len]=_data[i];
}

return *this;
}

MyString& MyString::insert(int index,const MyString&ms){
if(index<0 || index>_length)return *this;

_length=_length+ms._length;
if (_capacity<=_length){
while(_capacity<=_length)_capacity*=2;
char *tmp=new char[_capacity];
strncat(tmp,_data,index);
strcat(tmp,ms._data);
strcat(tmp,_data+index);
delete _data;
_data=tmp;
}
else{
char *tmp=new char[_length-index+1];
strcpy(tmp,_data+index);
strcpy(_data+index,ms._data);
strcat(_data,tmp);
delete tmp;
}

return *this;
}

MyString& MyString::append(const MyString& ms){
_length=_length+ms._length;
if (_capacity<=_length){
while(_capacity<=_length)_capacity*=2;
char *tmp=new char[_capacity];
strcat(tmp,_data);
strcat(tmp,ms._data);
delete _data;
_data=tmp;
}
else{
strcat(_data,ms._data);
}

return *this;
}

MyString::MyString():_data(new char('\0')),_length(0),_capacity(1){
}

MyString::MyString(const char* s):_capacity(1){
_length=strlen(s);
while(_capacity<=_length)_capacity*=2;
_data=new char[_capacity];
strcpy(_data,s);

}

MyString::MyString(const MyString& ms){
_length=ms._length;
_capacity=ms._capacity;
_data=new char[_capacity];
strcpy(_data,ms._data);

}

MyString::MyString(int n,char c):_length(n),_capacity(1){
while(_capacity<=_length)_capacity*=2;
_data=new char[_capacity];
char *src=_data;
while(n--){
*src++=c;
}
*src='\0';

}

MyString::~MyString(){
if(_data!=NULL){
delete _data;
_data=NULL;
}
_length=0;
_capacity=0;
}

void MyString::clear(){
*_data='\0';
_length=0;
}

char& MyString::operator[](int index){
if(index<0 || index>=_length)
return _data[_length];
return _data[index];
}

MyString MyString::operator+(MyString& ms){
MyString tmp;
while(tmp._capacity<=_length+ms._length)tmp._capacity*=2;
tmp._data=new char[tmp._capacity];
tmp._length=_length+ms._length;
strcat(tmp._data,_data);
strcat(tmp._data,ms._data);

return tmp;
}

void MyString::operator+=(MyString& ms){
_length=_length+ms._length;
if (_capacity<=_length){
while(_capacity<=_length)_capacity*=2;
char *tmp=new char[_capacity];
strcat(tmp,_data);
strcat(tmp,ms._data);
delete _data;
_data=tmp;
}
else{
strcat(_data,ms._data);
}

}
void MyString::operator+=(const char* ms){
_length=_length+strlen(ms);
if (_capacity<=_length){
while(_capacity<=_length)_capacity*=2;
char *tmp=new char[_capacity];
strcat(tmp,_data);
strcat(tmp,ms);
delete _data;
_data=tmp;
}
else{
strcat(_data,ms);
}

}

void MyString::operator=(const char*ms){
_length=strlen(ms);
if(_capacity<=_length){
while(_capacity<=_length)_capacity*=2;
delete _data;
_data=new char[_capacity];
}
strcpy(_data,ms);

}

void MyString::operator=(const MyString& ms){
_length=strlen(ms._data);
if(_capacity<=_length){
while(_capacity<=_length)_capacity*=2;
delete _data;
_data=new char[_capacity];
}
strcpy(_data,ms._data);
}

char& MyString::at(int index){
if (index<0 || index>=_length){
return _data[_length];
}

return _data[index];
}

char& MyString::at(int index)const{
if (index<0 || index>=_length){
return _data[_length];
}

return _data[index];
}

int main()
{
MyString ms="2121";
ms+="abc";
ms.append("789");
cout<<ms<<endl;
ms.insert(0,"ABC");
ms=ms.substr(0,5);
cout<<ms<<endl;

for(MyString::Iterator it=ms.begin();it!=ms.end();++it)
cout<<*it<<' ';
cout<<endl;
cout<<ms.length()<<" "<<ms.size()<<" "<<ms.capacity()<<endl;

return 0;
}

//结果
2121abc789
ABC21
A B C 2 1
5 5 16