c++之封装——string类型的实现

以前在C语言中并没有string这个内置类型，但是到了c++里面就可以使用了，c++中可以定义string变量，对string类型的变量可以进行各种操作，包括相加、相减、赋值等等，就和int ，double类型相似，但string是一个字符串。要实现这些操作并不像C语言的内置类型一样那么简单，直接数据进行运算就可以。
string的实现得益与c++的封装特性，封装是c++的三大特性之一，string类型其实是在char*类型的基础上进行一层封装。其实质还是基于C语言的内置类型数据上的操作。
简单的创建一个类，类名为string，类的私有成员为char*类型指针，为指针动态指针开辟一段空间，就可以在这段空间上进行操作了。

class String            
{
public:
 String(char *str = NULL) //构造
 {
  if (str == NULL)
  {
   _pstr = new char[1];
   *_pstr = '\0';
  }
  else
  {
   _pstr = new char[strlen(str) + 1];
   strcpy(_pstr, str);
  }

   ~String()
 {
  if (this->_pstr != NULL)
  {
   delete[] _pstr;
   _pstr = NULL;
  }
 }

private:
 char *_pstr;
};

对于string的操作有很多，这里主要实现string的一些运算和比较，比如比较两个字符串是否相等，在以前没有string类的时候，我们比较两个字符串需要写一个函数，对字符串进行遍历，在string中原理大致相同，但有了string类之后，就可以随时调用类的方法，在类中实现“==“运算符的重载，给出公用接口就可以了。

class String         
{
public:
 String(char *str = NULL) //构造
 {
  if (str == NULL)
  {
   _pstr = new char[1];
   *_pstr = '\0';
  }
  else
  {
   _pstr = new char[strlen(str) + 1];
   strcpy(_pstr, str);
  }

   ~String()
 {
  if (this->_pstr != NULL)
  {
   delete[] _pstr;
   _pstr = NULL;
  }
 }

 bool operator==(const String&s)
 {
  char* s1 = _pstr;
  char* s2 = s._pstr;
  while (*s1!='\0'&&*s2!='\0')
  {
   if (*s1 == *s2)
   {
    s1++;
    s2++;
    if (*s1 == '\0'&&*s2 == '\0')
    {
     return true;
    }
   }
   else
    return false;
  } 
  if (*s1 == '\0'&&*s2 == '\0')
  {
   return true;
  }
  else
  {
   return false;
  }
 }
private:
 char *_pstr;
};

此时，我们便可以轻松比较两个字符串是否相等

int main()
{
   string s1("abcd");
   string s2("cdef");
   int a=(s1==s2);
   return 0;
}

在进行string赋值操作时，由于字符串所占的空间可能超出为原指针开辟的空间，所以要进行判断并重新开辟空间

class String            
{
public:
 String(char *str = NULL)
 {
  if (str == NULL)
  {
   _pstr = new char[1];
   *_pstr = '\0';
  }
  else
  {
   _pstr = new char[strlen(str) + 1];
   strcpy(_pstr, str);
  }
 }

 ~String()
 {
  if (this->_pstr != NULL)
  {
   delete[] _pstr;
   _pstr = NULL;
  }
 }

 String& operator=(const String& s)
 {
  if (this != &s)
  {
   char *tmp = new char[strlen(s._pstr) + 1];
   strcpy(tmp, s._pstr);
   delete[] _pstr;             //释放原来的内存
   this->_pstr = tmp;
  }
  return *this;
 }

 private:
 char *_pstr;
};

下面是一个比较完整的string类的实现

class String           
{
public:
 String(char *str = NULL)
 {
  if (str == NULL)
  {
   _pstr = new char[1];
   *_pstr = '\0';
  }
  else
  {
   _pstr = new char[strlen(str) + 1];
   strcpy(_pstr, str);
  }

 }
 String(const String& s)
  :_pstr(new char[strlen(s._pstr)+1])
 {
  strcpy(_pstr, s._pstr);
 }

 ~String()
 {
  if (this->_pstr != NULL)
  {
   delete[] _pstr;
   _pstr = NULL;
  }
 }

 String& operator=(const String& s)
 {
  if (this != &s)
  {
   char *tmp = new char[strlen(s._pstr) + 1];
   strcpy(tmp, s._pstr);
   delete[] _pstr;
   this->_pstr = tmp;
  }
  return *this;
 }

 bool operator>(const String&s)
 {
  char* s1 = _pstr;
  char* s2 = s._pstr;
  while (*s1)
  {
   if (*s1 > *s2)
   {
    return true;
   }
   else if (*s1 < *s2)
   {
    return false;
   }
   else
   {
    s1++;
    s2++;
   }
  }
  return false;
 }

 bool operator>=(const String&s)
 {
  char* s1 = _pstr;
  char* s2 = s._pstr;
  while (*s1)
  {
   if (*s1 >= *s2)
   {
    return true;
   }
   else 
   {
    return false;
   }
  }
 }


 bool operator<(const String&s)
 {
  char* s1 = _pstr;
  char* s2 = s._pstr;
  while (*s1)
  {
   if (*s1 < *s2)
   {
    return true;
   }
   else if (*s1 > *s2)
   {
    return false;
   }
   else
   {
    s1++;
    s2++;
   }
  }
  return true;
 }

 bool operator<=(const String&s)
 {
  char* s1 = _pstr;
  char* s2 = s._pstr;
  while (*s1)
  {
   if (*s1 <= *s2)
   {
    return true;
   }
   else
   {
    return false;
   }
  }
 }

 bool operator==(const String&s)
 {
  char* s1 = _pstr;
  char* s2 = s._pstr;
  while (*s1!='\0'&&*s2!='\0')
  {
   if (*s1 == *s2)
   {
    s1++;
    s2++;
    if (*s1 == '\0'&&*s2 == '\0')
    {
     return true;
    }
   }
   else
    return false;
  } 
  if (*s1 == '\0'&&*s2 == '\0')
  {
   return true;
  }
  else
  {
   return false;
  }
 }

 bool operator!=(const String&s)
 { 
  if (_pstr == s._pstr)
   return false;
  else
   return true;
 }

 size_t Size()  // 模拟strlen
 {
  int count = 0;
  char* s = _pstr;
  while (*s)
  {
   count++;
   s++;
  }
  return count;
 }

 // 检测s是否是当前对象的子串
 bool StrStr(const String& s) // 模拟strstr
 {
  char *Str = _pstr;
  char* Substr = s._pstr;
  char *TStr;
  char *TSub;
  while (*Str)
  {
   TStr = Str;
   TSub = Substr;
   while(*Str == *Substr)
   {
    Str++;
    Substr++;
    if (*Substr == '\0')
    {
     return true;
    }
   }
   Str = TStr;
   Substr = TSub;
   Str++;
  }
  return false;
 }

 // 将当前对象从pos位置开始复制count个字符到p所指向的空间中
 // 返回复制到p中有效字符的个数 
 size_t Copy(char* p, size_t pos, size_t count)  // 模拟strcpy
 {
  assert(p);
  if (count <= 0)
  {
   return 0;
  }
  char *s1 = _pstr;
  while (pos--)
  {
   s1++;
  }
  if (*s1 = '\0'&&count>0)
  {
   *p = *s1;
   return 1;

  }
  int CopyNumber = 0;

  while (--count)
  {
   if (*s1 != '\0')
   {
    *p = *s1;
    p++;
    s1++;
    CopyNumber++;
   }
   else
   {
    return CopyNumber;
   }
  }
 }

private:
 char *_pstr;
};

string类有多种实现方式，前面只是比较常规的一种，仅供参考。