从零开始的C++（十）
string 成员函数的模拟实现：
1.构造函数：
string(const char* str = "")
:_capacity(0)
,_size(0)
,_str(nullptr)
{
int len = strlen(str);
_str = new char[len + 1];
strcpy(_str, str);
_size = _capacity = len;
}
void swap(string& s)
{
char* tmp = s._str;
s._str = _str;
_str = tmp;
int tmp_int = s._size;
s._size = _size;
_size = tmp_int;
tmp_int = s._capacity;
s._capacity = _capacity;
_capacity = tmp_int;
}
string(const string& s)
{
//法一
/* int len = strlen(s._str);
_str = new char[len + 1];
strcpy(_str, s._str);
_size = _capacity = len;*/
//法二
string tmp(s);
swap(tmp);
}对于传字符串的构造函数，利用参数化列表初始化了成员函数，再在函数内实现空间开辟、字符串拷贝、成员赋值。
对于传同类对象的拷贝构造，一种方法是重新开辟空间，并把内容拷贝过去，实现深拷贝。一种方法是服用传字符串的构造函数，此时临时对象的内容就是所需要的内容，所以用一个swap函数将临时对象的成员内容和this指向的对象的成员内容互换，然后函数结束后对临时对象调用析构，处理了原本属于this指向的对象的内容的销毁。
2.赋值函数：
string& operator=(const string& s)
{
//法一
/* _size = s._size;
_capacity = s._capacity;
char* tmp = new char[_capacity+1];
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;
return *this;*/
//法二
string tmp(s._str);
swap(tmp);
}
赋值函数的内容和传递对象的拷贝构造十分相似，都是将一个对象的内容深拷贝到另一个对象中，因此方法也有两种，原理和上述类似。
3.析构函数：
~string()
{
delete[]_str;
_size = _capacity = 0;
}
析构函数的主要作用就是销毁开辟的空间。
4.插入内容：
void reverse(size_t n)
{
if (n > _capacity)
{
_capacity = n;
char* tmp = new char[_capacity + 1];
strcpy(tmp, _str);
_str = tmp;
}
}
void push_back(char c)
{
//扩容
if (_size == _capacity)
{
reverse(2 * _capacity + 1);
}
_str[_size] = c;
_str[++_size] = '\0';
}
string& operator+=(char c)
{
push_back(c);
return *this;
}
void append(const char* str)
{
int len = strlen(str);
if (_size+len> _capacity)
{
reverse(_size + len);
}
strcat(_str, str);
_size += len;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}push_back()用于插入一个字符，append用于插入一个字符串，重载+=能实现插入一个字符或一个字符串，功能和push_back和append类似，因此直接复用，同时针对字符和字符串进行了函数重载。
5.insert和erase：
// 在pos位置上插入字符c/字符串str，并返回该字符的位置
string& insert(size_t pos, char c)
{
assert(pos <= _size);
*this += c;
for (int i = _size; i > pos; i--)
{
_str[i] = _str[i - 1];
}
_str[pos] = c;
_str[_size] = '\0';
return *this;
}
string& insert(size_t pos, const char* str)
{
assert(pos <= _size);
int len = _size + strlen(str);
int len1 = strlen(str);
reverse(len);
for (int i =_size; i >=(int)pos ; i--)
{
_str[i+len1] = _str[i];
}
for (int i = pos,j=0; i < pos+len1; i++)
{
_str[i] = str[j++];
}
_size = len;
return *this;
}
// 删除pos位置上的元素，并返回该元素的下一个位置
string& erase(size_t pos, size_t len=-1)
{
assert(pos <_size&&pos>=0);
if (len == -1||pos+len>=_size)
{
_size = pos;
_str[_size] = '\0';
}
else
{
for (int i = pos + len; i < _size; i++)
{
_str[i - len] = _str[i];
}
_size -= len;
_str[_size] = '\0';
}
return *this;
}
insert函数实现在pos位置插入一个字符或一个字符串，需要注意pos的类型是size_t，如果是头插用pos做循环条件可能会进行无限循环（即循环条件是大于或等于pos，此时pos等于0，但size_t类型永远大于或等于0）。
erase函数实现在pos位置删除len个字符，如果len忽略或者len过大，相当于删除pos位置往后所有字符，因此需要判断len。
6。流提取：
istream& operator>>(istream& _cin, bit::string& s)
{
//充当临时缓冲区
char tmp[101];
s.clear();
char ch;
_cin.get(ch);
int i = 0;
while (ch != '\n' && ch != ' ')
{
if (i == 100)
{
tmp[i] = '\0';
s += tmp;
i = 0;
}
tmp[i++] = ch;
_cin.get(ch);
}
if (i != 0)
{
tmp[i] = '\0';
s += tmp;
}
return _cin;
}对于流提取，本函数的实现方式是一个字符一个字符的插入，如果直接放入this指向对象中，会存在多次扩容，效率低。因此使用了一个临时缓冲区，缓冲区未满的时候内容放入缓冲区中，满了以后把缓冲区的内容全放入this指向的对象中，再清空缓冲区。需要注意，在退出循环后缓冲区中仍可能存在内容未放入this指向对象中，因此还需要放入一次。