注意：

1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一
   致，一般情况下基本都是用size()。

2. clear()只是将string中有效字符清空，不改变底层空间大小。

3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字
   符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的
   元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大
   小，如果是将元素个数减少，底层空间总大小不变。

4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于
   string的底层空间总大小时，reserver不会改变容量大小。

2. string类的模拟实现

上面已经对string类进行了简单的介绍，大家只要能够正常使用即可。在面试中，面试官总喜欢让我们自己
来模拟实现string类，最主要是实现string类的构造、拷贝构造、赋值运算符重载以及析构函数。

这里主要把最主要的几个函数接口实现特殊拿出来处理，其他的完整实现就放在最下面的mini版string完整代码中

实现string的构造

string的构造有很多，我们没必要全部实现，只需实现最主要的即可！

下面我们用一个缺省的构造函数，可以实现无参和有参字符串的构造。

为了避免和C++标椎库中的string冲突，我们可以用命名空间封装起来，下面全部的模拟实现都在该命名空间中

namespace hdm
{class string{public://构造函数string(const char* str = ""){_size = strlen(str);_capacity = _size;_str = new char[_capacity + 1];strcpy(_str, str);}private:char * _str;size_t _size;size_t _capacity;const static size_t  npos = -1;};
}

实现string的析构函数

析构函数相对来说比较简单，我们只需要对字符串的空间进行释放即可

~string()
{delete[]_str;_str = nullptr;_capacity = _size = 0;
}

实现reserve和resize

reserve是为字符串预留空间，简单来说就是用来预先开辟好空间(扩容)，避免后续频繁扩容。

resize是将有效字符的个数该成n个，多出的空间用字符c填充，具体代码如下

注意：resize要分情况讨论

void reserve(size_t n)
{if (n > _capacity){char * tem = new char[n + 1];strcpy(tem, _str);delete[] _str;_str = tem;_capacity = n;}
}void resize(size_t n, const char c)
{if (n > _capacity){reserve(n);for (size_t i = _size; i < n; ++i){push_back(c);}}else if (n > _size){for (size_t i = _size; i < n; ++i){push_back(c);}}_size = n;_str[_size] = '\0';
}

实现string的拷贝构造

string的拷贝构造有两种写法

1. 老老实实中规中矩的写法

   重新开辟一个空间，将字符串拷贝到新空间上

//传统写法
string(const string& s)
{_str = new char[s._capacity + 1];_capacity = s._capacity;_size = s._size;strcpy(_str, s._str);
}

2. 现代写法

可以叫工具人写法，直接用要拷贝对象的字符串来构造一个临时对象，然后用它来交换即可

//现代写法
string(const string &s):_str(nullptr), _size(0), _capacity(0)
{string tem(s._str);swap(tem);
}void swap(string& s)
{std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);
}

实现string赋值运算符重载

string的赋值运算符重载也有两种方式实现

1. 老老实实中规中矩的写法

自己开空间，自己拷贝数据

//传统写法
string& operator=(const string &s)
{if (this != &s){char * tem = new char[s._capacity + 1];strcpy(tem, s._str);delete[] _str;_str = tem;_capacity = s._capacity;_size = s._size;}return *this;
}

2. 现代写法

也是工具人写法，本质上跟拷贝构造一个道理

//现代写法
string& operator=(string s)
{swap(s);return *this;
}
void swap(string& s)
{std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);
}

实现string的insert函数

string的insert函数有两个，一种是插入一个字符，另一种是插入一个字符串

其中插入一个字符相对来说比较简单，对于插入一个字符串的边界处理比较考验对代码的把控。

1. 插入一个字符

// 在pos位置上插入字符c
string& insert(size_t pos, char c)
{assert(pos <= _size);if (_size == _capacity){size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}for (size_t i = _size + 1; i > pos; --i){_str[i] = _str[i - 1];}_str[pos] = c;_size++;return *this;
}

2. 插入一个字符串

// 在pos位置上插入字符串str
string& insert(size_t pos, const char* str)
{assert(pos <= _size);size_t len = strlen(str);if (_size + len >= _capacity){reserve(_size + len);}size_t end = _size + len;while (end > pos + len - 1)//将pos到_size中的字符往后移{_str[end] = _str[end - len];--end;}strncpy(_str + pos, str, len);//在pos位置插入str_size += len;return *this;
}

mini版string完整代码

#include
#include
using namespace std;namespace hdm
{class string{public:typedef char* iterator;//迭代器string(const char* str = ""){_size = strlen(str);_capacity = _size;_str = new char[_capacity + 1];strcpy(_str, str);}//传统写法/*string(const string& s){_str = new char[s._capacity + 1];_capacity = s._capacity;_size = s._size;strcpy(_str, s._str);}
*///现代写法string(const string &s):_str(nullptr), _size(0), _capacity(0){string tem(s._str);swap(tem);}//传统写法//string& operator=(const string &s)//{//	if (this != &s)//	{//		char * tem = new char[s._capacity + 1];//		strcpy(tem, s._str);//		delete[] _str;//		_str = tem;//		_capacity = s._capacity;//		_size = s._size;//	}//	return *this;//}//现代写法string& operator=(string s){swap(s);return *this;}~string(){delete[] _str;_str = nullptr;_capacity = _size = 0;}char& operator[](size_t index){assert(index < _size);return _str[index];}const char& operator[](size_t index)const{assert(index < _size);return _str[index];}const char* c_str()const{return _str;}// iteratoriterator begin()const {return _str;}iterator end()const{return _str + _size;}// modifyvoid push_back(char c){if (_capacity == _size){size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;char *tem = new char[newcapacity + 1];_str = tem;_capacity = newcapacity;}_str[_size++] = c;_str[_size] = '\0';}string& operator+=(char c){push_back(c);return *this;}void append(const char* str){size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}strcpy(_str + _size, str);_size += len;}string& operator+=(const char* str){append(str);return *this;}void clear(){_size = 0;_str[0] = '\0';}void swap(string& s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}// capacitysize_t size()const{return _size;}size_t capacity()const{return _capacity;}bool empty()const{return _size == 0;}void resize(size_t n, char c = '\0'){if (n>_capacity){reserve(n);memset(_str + _size, c, n - _size);}else if (n<_capacity && n>_size){memset(_str + _size, c, n - _size);}_size = n;_str[n] = '\0';}void reserve(size_t n){if (n > _capacity){char *tem = new char[n + 1];strcpy(tem, _str);delete[] _str;_str = tem;_capacity = n;}}//relational operatorsbool operator<(const string& s)const{return !(*this>s);}bool operator<=(const string& s)const{return *this < s || *this == s;}bool operator>(const string& s)const{if (strcmp(_str, s._str) > 0){return true;}return false;}bool operator>=(const string& s)const{return !(*this <= s);}bool operator==(const string& s)const{return strcmp(_str, s._str) == 0;}bool operator!=(const string& s)const{return !(*this == s);}// 返回c在string中第一次出现的位置size_t find(char c, size_t pos = 0) const{for (size_t i = pos; i < _size; ++i){if (_str[i] == c){return i;}}return npos;}// 返回子串s在string中第一次出现的位置size_t find(const char* s, size_t pos = 0) const{char* tem=strstr(_str + pos, s);return tem - _str;;}// 在pos位置上插入字符cstring& insert(size_t pos, char c){assert(pos <= _size);if (_size == _capacity){size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}for (size_t i = _size + 1; i > pos; --i){_str[i] = _str[i - 1];}_str[pos] = c;_size++;return *this;}// 在pos位置上插入字符串strstring& insert(size_t pos,const char* str){assert(pos <= _size);size_t len = strlen(str);if (_size + len >= _capacity){reserve(_size + len);}size_t end = _size + len;while (end > pos+len-1){_str[end] = _str[end-len];--end;}strncpy(_str + pos, str, len);_size += len;return *this;}// 删除pos位置上的元素string& erase(size_t pos, size_t len=npos){assert(pos < _size);if (pos + len>_size){_str[pos] = '\0';_size = pos;}else{strncpy(_str + pos, _str + pos + len, _size-len+1);_size -= len;}return *this;}private:char* _str;size_t _capacity;size_t _size;const static size_t npos = -1;};ostream& operator<< (ostream& out, string & s){for (size_t i = 0; i < s.size(); ++i){out << s[i];}return out;}istream& operator>>(istream& in, string&s){s.clear();char buff[128] = { '\0' };char ch = in.get();int i = 0;while (ch != ' '&& ch != '\n'){if (i == 127){s += buff;i = 0;}buff[i++] = ch;ch = in.get();}if (i > 0){buff[i] = '\0';s += buff;}return in;}
}