前言：在C语言中，我们经常使用字符串进行一系列操作，经常使用的函数如下：增删改查

（自己造轮子），C++中设计出string容器，STL库中为我们提供了以上函数，所以我们使用string容器时，就不用造轮子了

参考网站：https://legacy.cplusplus.com/reference/string/string/?kw=string

底层实现，这里我用的是VS的编译器（window）（简化版本），linux（g++）这里使用计数引用（这里不采用计数引用实现）

constructor（构造函数）

第一个（第四个）：是无参构造

#include<string>
#include<iostream>
using namespace std;
int main()
{string s;return 0;
}

s中只含有'\0'（无参构造时）

底层实现：（运用全缺省构造）

string(const char* arr = "")
{int len = strlen(arr);_str = new char[len + 1];// '\0'要单独开空间strcpy(_str, arr);_size = len;_capacity = len;
}

第二个：拷贝构造（将 str 中的所有成员变量全部赋值给*this）

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

第三个：将str中的字符串从下标为pos ,拷贝字符的个数为npos

（注意npos 为默然时，则为字符串能存储最多的个数，不是_capacity，而是系统默然能储存的最大值，此时npos = -1）

当npos > len - pos 时 ， 就拷贝全部

举个例子：

destructor（析构函数）

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

operator=（赋值重载）

​
string& operator=(const string& s)
{char* tmp = new char[s._capacity + 1];strcpy(tmp, s._str);_size = s._size;_capacity = s._capacity;delete[] _str;_str = tmp;return *this;
}
//现代写法
string& operator=(string s)
{swap(s);return *this;
}
​

现代写法含义：传参时，s进行拷贝构造，在交换*this与s

iterator（迭代器）

迭代器的行为像指针

范围for的原理就是迭代器

#include<string>
#include<iostream>
using namespace std;
int main()
{string s("0000000000000000000");string::iterator it = s.begin();while (it != s.end()){cout << *it << " ";it++;}cout << endl;
return 0;
}#include<string>
#include<iostream>
using namespace std;
int main()
{string s("0000000000000000000");for( auto e : s )cout << e << " ";cout << endl;return 0;
}

这两个代码等效，原理都是迭代器

//迭代器底层实现
char* begin()
{return _str;
}
char* end()
{return _str + _size;
}char* rbegin()
{return _str + _size;
}
char* rend()
{return _str;
}

capacity（容量）

_capacity当前开辟的空间最多能储存多少字符

_size代表当前有多少个有效的字符

库里面有提供查询_capacity,_size的函数

int size()
{
return _size;
}
int capacity()
{
return _capacity;
}

如何扩容：（库里面有两个函数，可以实现扩容）

第一个reserve

传入一个size_t的参数，作为要扩容到标准

当 n <= _capacity 一般不会造成缩容（这个要具体看编译器）

当 n > _capacity 会扩容

void reserve(size_t n = 0)
{if (n <= _capacity)return;else{char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}
}

第二个resize函数

当 n < _size 会造成有效数据的删除（有可能会缩容）

当 n > _size 且n < _capacity 有可能会缩容，但会造成添加有效数据，一直到 n

当 n > _capacity 会造成扩容，并添加有效数据的个数，一直到 n 

void resize(size_t n, char c = '\0')
{if (n <= _size){_size = (int)n;_str[n] = '\0';}else{reserve(n);for (; _size < n; _size++){_str[_size] = c;}_str[_size] = '\0';// n为最多有效字符个数,_str[n] = '\0';}
}

clear函数

清空有效数据，令_size = 0;

empty函数

判断有效数据个数是否为0

operator[]

放回下标为pos的字符

char& operator[] (size_t pos)
{assert(pos < _size);return _str[pos];
}
const char& operator[] (size_t pos) const
{assert(pos < _size);return (const char )_str[pos];
}

需要assert（判断pos < _size ）,防止对未进行赋值的位置解引用

operator+=（传入的是字符串也可以，因为会进行隐式类型转换）

string& operator+=(const string& s)
{if (s._size + _size > _capacity ){reserve(s._size + _size);}strcpy(_str + _size, s._str);_size += s._size;return *this;
}

在字符串末尾添加字符串

具体使用：与整形变量的使用方法一样

append（传入的是字符串也可以，因为会进行隐式类型转换）

string& append(const string& str)
{*this += str;//复用上面的+=return *this;
}

举个例子：

push_back

在字符串末尾添加一个字符

void push_back(char ch)
{if (_size == _capacity){reserve(_size * 2);}_str[_size++] = ch;_str[_size] = '\0';
}

assign（容量不改变）

第一个,第三个相当与拷贝构造

第二个就是将str中的字符串中的下标从subpos位置的sublen个字符，拷贝给*this

string& assign(const string& str, size_t subpos, size_t sublen)
{assert(_size - subpos >= sublen && sublen >= 0 );if (sublen > _capacity)reserve(sublen + _capacity);memcpy(_str, str._str + subpos, sublen);_size = sublen;_str[_size] = '\0';return *this;
}

第四个将s中的字符串前n个字符，给*this;

string& assign(const char* s, size_t n)
{if (n > _capacity)reserve(n);memcpy(_str, s, n);_size = n;_str[_size] = '\0';return *this;
}

第五个将n个字符c给*this

string& assign(size_t n, char c)
{if (n > _capacity)reserve(n);for (int i = 0; i < n; i++){_str[i] = c;}_size = n;_str[n] = '\0';return *this;
}

insert

请注意可以插入一个string

在pos位置前插入字符或字符串

string& insert(size_t pos, char c)
{
if( _capacity == _size )reserve( 2 * _size );for (size_t i = _size; i > pos; i--){_str[i] = _str[i - 1];}_size++;_str[pos] = c;
}string& insert(size_t pos, const char* str)
{int len = strlen(str);if (len + _size > _capacity)reserve(len + _size);for (size_t i = _size + len  ; i >= pos + len; i--){_str[i] = _str[i - len];}_size += len;memcpy(_str + pos, str, sizeof(char) * len);return *this;
}

使用方法：

自定义类型的变量 . insert ( 参数列表 ）

erase

string& erase(size_t pos = 0, size_t len = npos)
{assert(pos >= 0);if (pos + len >= _size)_size = pos;else{for (size_t i = pos + len; i < _size; i++){_str[i - len] = _str[i];}_size -= len;}_str[_size] = '\0';return *this;
}

从下标为pos的位置，删除len个字符，其中当len == npos时，就将从pos位置起以后（包括pos位置的数据）的数据删除

find

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 -1;//npos
}
size_t find(const char* s, size_t pos = 0) const
{char* tmp = strstr(_str , s );if (tmp == nullptr)return -1;else return tmp - _str;
}

找寻_str中是否存在字符c或字符串s,如果存在返回第一次出现时的下标

不存在，返回-1