string类的模拟实现

模拟实现

class String
{
public:
typedef char* iterator;

private:
size_t _size;
size_t _capacity;
char* _str;
}

构造函数

String(char* s="")
{
_size=strlen(s);
_capacity=_size;
_str=new char[_capacity+1];
strcpy(_str,s);
}

拷贝构造（传统写法）

String(const String& s)
{
_str=new char[strlen(s._str)+1];
strcpy(_str,s._str);
_size=s._size;
_capacity=s._capacity;
}

拷贝构造（现代写法）

String(const String& s)                  
 {
  _str = nullptr;
  String str(s._str);
  swap(_str, str._str);
 }

赋值运算符（传统写法）

String& operator=(const String& s)        
 {
  if (this == &s)
  {
   return *this;
  }
  char* str = new char[strlen(s._str) + 1];
  strcpy(str, s._str);
  delete[] _str;
  _str = str; 
  return *this;
 }

赋值运算符（现代写法）

String& operator=(String s)
{
swap(_str,s._str);
return *this;
}

扩容

void Reserve(size_t n)
{
if(n>_capacity)
{
char* s1=new char[n+1];
strcpy(s1,_str);
delete[] _str;
_str=s1;
_capacity=n;
}
}

尾插字符

void pushback(char c)          
 {
  if (_size == _capacity)
  {
   size_t n =( _size == 0 ? 15 : 2 * _capacity);
   Reserve(n);
  } 
  _str[_size++] = c;
  _str[_size] = '\0';
 }

尾插字符串

void append(const char* str)   
 {
  int len = strlen(str);
  if ((len + _size) > _capacity)
  {
   Reserve(len+_size);
  }
  strcpy(_str + _size, str);
  _size += len;
 }

Resize

void Resize(int n,char c='\0')
{
if(n<_size)
{
_size=n;
_str[n]='\0';
}
else if((n>_size)&&(n<_capacity))
{
for(int i=_size;i<n;i++)
{
_str[i]=c;
}
_size=n;
_str[n]='\0';
}
else if(n>_capacity)
{
Reserve(n);
memset(_str+_size,c,n-_size);
_size=n;
_str[_size]='\0';
}
}

插入单个字符

void insert(int pos,char c)
{
assert(pos<=_size);
Reserve(_size+1);
int end=_size;
while(end>pos)
{
_str[end]=_str[end-1]；
end--;
_str[pos]=c;
++_size;
_str[_size]='\0'；
}
}

插入字符串

void insert(int pos,char* c)
{
assert(pos<=_size);
int len=strlen(c);
int end=_str+len;
Reserve(end+1);
while(end>pos+len-1)
{
_str[end]=_str[end-len];
end--;
}
for(int i=0;i<len;i++)
{
_str[pos+i]=c[i];
}
_size+=len;
_str[_size]='\0';
}

删除

void erase(inr pos, int len)
{
if(pos+len>_size)
{
_size=pos;
_str[_size]='\0';
}
else if(pos+len<=_size)
{
for(int i=0;i<_size-pos-len;i++)
{
_str[pos+i]=_str[pos+len+i];
}
_size-=len;
_str[_size]='\0';
}
}

operator+=

String& operator+=(const String& s)
 {
  append(s._str);
  return *this;
 }
 
 String& operator+=(const char c)
 {
 pushback(c);
 return *this;
 }

查找单个字符

size_t find(const char c)
{
for(int i=0;i<_size;i++)
{
     if(_str[i]==c)
     {
     return i;
     }
}
return npos;
}

查找字符串

size_t find(const char* str)
{
char* start=strstr(_str,str);
if(strart)
{
  return start-_str;
}
return npos;
}

模拟实现strstr

char* Strstr(char* dest,char* str)
{
while(*dest)
{
if(*dest==*str)
{
   char* mdest=dest;
   char* mstr=str;
   while(*mdest&&*str)
   {
     if(*mdest!=*str)
     {
      break;
      mstr++;
      mdest++;
     }
     if(*mstr=='\0')
     {
       return dest;
     }
   }
}
dest++;
}
return nullptr;
}

两个对象相加

String operator+(const String& s2)
{
String s(*this);
s.append(s2._str);
return s;

//String s(*this);
//s+=s2;
//return s;
}

迭代器

iterator begin()
{
 return _str;
}
iterator end()
{
 return _str+_size;
}

析构函数

~String()
{
if(_str)
{
delete[] _str;
_str=nullptr;
}
}

operator[]

char& operator[](size_t i)
{
return _str[i];
}