java仿写string类,c++ STL string类仿写

#include

#include

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<

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<

out<

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

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>

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

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.insert(0,"ABC");

ms=ms.substr(0,5);

cout<

for(MyString::Iterator it=ms.begin();it!=ms.end();++it)

cout<

cout<

cout<

return 0;

}

//结果

2121abc789

ABC21

A B C 2 1

5 5 16