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