string相关

这些构造函数其中常用的有：第一个无参构造，第二个拷贝构造，第四个字符串初始化，第六个使用n个字符c初始化。

其他几个构造可以了解，比如第三个：拷贝某个字符串，从pos位置开始拷贝，拷贝长度为len，这里len给了缺省值npos，npos=-1，但因为是无符号整型，所以它在这里是整型的最大值，也就是说不传第三个参数，默认传了整型最大值，也就是从pos位置拷贝到字符串结尾

由于string在类外面重载了<<和>>所以支持流插入和流提取

对于string对象的尾插，有几种方式：

1.push_back，只能尾插一个字符；

2.append，可以追加字符串，string对象等，使用广泛

实际场景中除了喜欢使用这两种方式，string还重载了+=运算符，使得尾插变得更加简洁。

string类对象的访问及遍历操作：

string重载了[ ]，其本质就是解引用，类似于数组，因此string也可类似的使用下标访问各位置的值

有两种传参方式，普通对象调用第一个，返回普通对象的引用，const对象调用第二个，返回const对象的引用，const对象不可修改，如果是普通对象那么可以利用[ ]进行修改，使用方式类似于数组

string的迭代器底层就是指针，它的使用方式如下：

访问string的方式除了上面的两种方式（[ ]下标访问；迭代器访问），还有一种方式：范围for，迭代器的使用可能比[ ]繁琐，但是范围for的底层就是迭代器，这是迭代器的一个好处，迭代器的另一个好处是迭代器是通用的，任何容器都支持迭代器，用法类似。

为什么一定要有迭代器，因为下标加[ ]未必所有容器都适用，比如链表，它的空间是不连续的，但是可以使用迭代器。

迭代器有普通迭代器和const迭代器，const迭代器只支持读，普通迭代器还支持写操作

迭代器还可以分成正向迭代器(begin(获取首个字符的迭代器)+end(获取最后一个字符的下一个位置的迭代器))和反向迭代器(rbegin+rend)

size ： 返回字符串有效字符长度

length  ： 返回字符串有效字符长度

capacity  ： 返回空间总大小

empty  ： 检测字符串释放为空串，是返回 true ，否则返回 false

clear  ： 清空有效字符

reserve  ： 为字符串预留空间

resize  ： 将有效字符的个数该成 n 个，多出的空间用字符 c 填充

注意：

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 不会改变容量大小。

5.capacity的值不同的编译器结果不一定相同，取决于不同编译器的扩容机制

push_back ： 在字符串后尾插字符 c

append ： 在字符串后追加一个字符串（常用）

insert： 在字符串的某个位置插入字符（不常用）

operator+= ： 在字符串后追加字符串str

erease：  删除某一位置的字符（不常用）

c_str： 返回 C 格式字符串

find ： 从字符串 pos 位置开始往后找字符 c ，返回该字符在字符串中的位置

rfind ： 从字符串 pos 位置开始往前找字符 c ，返回该字符在字符串中的位置

substr ： 在 str 中从 pos 位置开始，截取 n 个字符，然后将其返回

string非成员函数：

operator+ ： 尽量少用，因为传值返回，导致深拷贝效率低

operator>> ： 输入运算符重载

operator<< ： 输出运算符重载

getline ： 获取一行字符串

relational operators ：  大小比较

string的其他操作：(具体看c++文档)

string模拟实现

构造&拷贝构造

析构函数

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

赋值运算符重载

迭代器

typedef char* iterator;
typedef const char* const_iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}const_iterator begin() const{return _str;}const_iterator end() const{return _str + _size;}

string类对象的容量操作相关函数

size_t size() const{return _size;}
void reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];memcpy(tmp, _str, _size+1);delete[] _str;_str = tmp;_capacity = n;}}
void resize(size_t n, char ch = '\0'){if (n < _size){_size = n;_str[_size] = '\0';}else{reserve(n);for (size_t i = _size; i < n; i++){_str[i] = ch;}_size = n;_str[_size] = '\0';}}void clear(){_str[0] = '\0';_size = 0;}

string类对象的修改操作

void push_back(char ch){if (_size == _capacity){// 2倍扩容reserve(_capacity == 0 ? 4 : _capacity * 2);}_str[_size] = ch;++_size;_str[_size] = '\0';}void append(const char* str){size_t len = strlen(str);if (_size + len > _capacity){// 至少扩容到_size + lenreserve(_size + len);}memcpy(_str + _size, str, len+1);_size += len;}
void insert(size_t pos, size_t n, char ch){assert(pos <= _size);if (_size + n > _capacity){// 至少扩容到_size + lenreserve(_size + n);}// 挪动数据size_t end = _size;while (end >= pos && end != npos)//npos=-1，end != npos防止的是pos为0时的情况，{                                //此时前一个判断条件只有在end小于0时才会结束，但是end是无符号整型_str[end + n] = _str[end];--end;}for (size_t i = 0; i < n; i++){_str[pos + i] = ch;}_size += n;}void insert(size_t pos, const char* str){assert(pos <= _size);size_t len = strlen(str);if (_size + len > _capacity){// 至少扩容到_size + lenreserve(_size + len);}size_t end = _size;while (end >= pos && end != npos){_str[end + len] = _str[end];--end;}for (size_t i = 0; i < len; i++){_str[pos + i] = str[i];}_size += len;}void erase(size_t pos, size_t len = npos){assert(pos <= _size);if (len == npos || pos + len >= _size){_str[pos] = '\0';_size = pos;_str[_size] = '\0';}else{size_t end = pos + len;while (end <= _size){_str[pos++] = _str[end++];}_size -= len;}}
size_t find(char ch, size_t pos = 0){assert(pos < _size);for (size_t i = pos; i < _size; i++){if (_str[i] == ch){return i;}}return npos;}size_t find(const char* str, size_t pos = 0){assert(pos < _size);const char* ptr = strstr(_str + pos, str);if (ptr){return ptr - _str;//返回下标}else{return npos;}}string substr(size_t pos = 0, size_t len = npos){assert(pos < _size);size_t n = len;if (len == npos || pos + len > _size){n = _size - pos;}string tmp;tmp.reserve(n);for (size_t i = pos; i < pos + n; i++){tmp += _str[i];}return tmp;//调用拷贝构造，必须深拷贝}const char* c_str() const{return _str;}

运算符重载相关函数

        bool operator<(const string& s) const{int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);return ret == 0 ? _size < s._size : ret < 0;}bool operator==(const string& s) const{return _size == s._size&& memcmp(_str, s._str, _size) == 0;}bool operator<=(const string& s) const{return *this < s || *this == s;}bool operator>(const string& s) const{return !(*this <= s);}bool operator>=(const string& s) const{return !(*this < s);}bool operator!=(const string& s) const{return !(*this == s);}

完整代码