string引用计数的写时拷贝

string的各种实现：

#include <string>
class String
{
public:
String(char* str = "")
	 :_str(new char[strlen(str) + 5])
 {
	 strcpy(_str+4, str);
	 _str += 4;
	 GetRefCount() = 1;
 }

 String(const String& s)
	 :_str(s._str)
 {
     GetRefCount()++;
 
 }

void Swap(String& s)
{
    String* p;
	p = s._str;
	s._str = str;
	str = p;
}
 
~String()
{
   if(--GetRefCount() == 0)
   {
       delete[](_str - 4);
   }
}

int&  GetRefCount()
{
   return  *((int*)(_str - 4));

}

String& operator=(String s)
{
    if(_str != s._str)
	{
	   if(--GetRefCount() == 0)
	   {
         delete[](_str - 4);
	   }
       _str = s._str;
      GetRefCount()++;
	}
	return *this;
}

const char* GetStr()
{
   return _str;

}

size_t Size()
{
   return  _size;

}

size_t Capacity()
{
   return _capacity;
}

void PushBack(char ch)
{
	if(_size >= _capacity)
	{
	  Expand(_capacity * 2);
	}
   _str[_size++] = ch;
   _str[_size] = '\0';
}

void PushBack(const char* str)
{
	size_t len = strlen(str) + _size;
    if(len >= _capacity)
	{
	  Expand(_capacity * 2);
	}
   while(*str)
   {
      _str[_size++] = *str;
	  str++;
   }
   _str[_size] = '\0';
}




void PopBack()
{
   _str[_size - 1] = '\0';
   _size--;
}

void Insert(size_t pos, char ch)
{
	if(_size > _capacity)
	{
	   Expand(_capacity * 2);
	}
	int end = _size;
	while(end >= (int)pos)
	{
	   _str[end + 1] = _str[end];
	   end--;
	}
	_str[pos] = ch;
	_size++;
}


void Insert(size_t pos, const char* str)
{
    if((_size + strlen(str)) > _capacity)
	{
	   Expand(_capacity * 2);
	}
	int len = strlen(str);
	size_t i = _size;
	while(i >= pos)
	{
	  _str[i + len]  = _str[i];
	  i--;
 	}
	while(*str)
	{
	   _str[pos] = *str;
	   pos++;
	   str++;
	}
	
	_size = _size +strlen(str);
}


void Erase(size_t pos, size_t count)
{
	size_t len = pos + count;
    if(len >= _size)
	{
	    _str[pos] = '\0';
	}
	else
	{
   while(_str[len])
   {
	   _str[pos] = _str[len];
	   len++;
	   pos++;
   }
   _size -= count;
   _str[_size] = '\0';
	}

}


size_t Find(char ch) const
{
    if(_str == NULL)
	{
	    exit(1);
	}		
	char* cur = _str;
	while(*cur)
	{
	    if(*cur == ch)
		{
		   return (cur - _str);
		}
		cur++;
	}
cout<< "字符串中没有此字符"<<endl;
system("pause");
exit(1);
}

size_t Find(const char* str) const
{
     char* cur = _str;
	 char* src = str;
	 if(_str == NULL)
	 {
	    exit(1);
	 }
	 while(*cur)
	 {
		 char* p = cur;
		while(*src)
		 {
		     if(*p == *src)
			 {
			     p++;
				src++;
			 }
			 else
			 {
			   break;
			 }
		}
         if(*src == '\0')
	    {
	    return sub -_str + 1;
	    }
	    
		cur++;
	    break;
	 }

	 cout<<"原字符串中没有此字符串"endl;
	 system("pause");
	 exit(1);
}









char& operator[](size_t pos)
{
   assret(pos < _size);
   return _str[pos];
}

bool operator<(const String& s) const
{
    for(size_t i = 0; i < _size && i < s._size; ++i)
	{
	  if(_str[i] < s._str[i])
	  {
	     return true;
	  }
	  else if(_str[i] > s._str[i])
	  {
	    return false;
	  }

	}
      if(i == _size && i < s._size)
	  {
	     return true;
	  }
	  else
	  {
	     return false;
	  }
}

bool operator<=(const String& s) const
{
    return !(_str >s._str);
}
bool operator>(const String& s) const
{
      for(size_t i = 0; i < _size && i < s._size; ++i)
	{
	  if(_str[i] > s._str[i])
	  {
	     return true;
	  }
	  else if(_str[i] < s._str[i])
	  {
	    return false;
	  }

	}
      if(i < _size && i == s._size)
	  {
	     return true;
	  }
	  else
	  {
	     return false;
	  } 
}

bool operator>=(const String& s) const
{
   return !(_str <s._str;
}

bool operator==(const String& s) const
{
 for(size_t i = 0; i < _size && i < s._size; ++i)
	{
	  if(_str[i] > s._str[i])
	  {
	     return false;
	  }
	  else if(_str[i] < s._str[i])
	  {
	    return false;
	  }

	}
      if(i == _size && i == s._size && _str[_size] == s.str[s._size])
	  {
	     return true;
	  }
	  else
	  {
	     return false;
	  }
}

bool operator!=(const String& s)const
{
  return !(_str == s._str);
}

void Expand(size_t n)
{
   if(n > _capacity)
   {
     _str = (char*)realloc(_str, n+1);
	 assert(_str);
	 _capacity = n;
   
   }
}