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

{

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

{

char* s1 = _pstr;

char* s2 = s._pstr;

while (*s1)

{

if (*s1

{

return true;

}

else if (*s1 > *s2)

{

return false;

}

else

{

s1++;

s2++;

}

}

return true;

}

bool operator

{

char* s1 = _pstr;

char* s2 = s._pstr;

while (*s1)

{

if (*s1

{

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

{

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类有多种实现方式，前面只是比较常规的一种，仅供参考。