string类详解

 为什么学习string类？

1.1 C语言中的字符串

C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可 能还会越界访问。

1.2面试题

在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本 都使用string类，很少有人去使用C库中的字符串操作函数。

string类oj题

344. 反转字符串 - 力扣（LeetCode）

387. 字符串中的第一个唯一字符 - 力扣（LeetCode）

LCR 192. 把字符串转换成整数 (atoi) - 力扣（LeetCode）

字符串最后一个单词的长度_牛客题霸_牛客网

125. 验证回文串 - 力扣（LeetCode）

541. 反转字符串 II - 力扣（LeetCode）

557. 反转字符串中的单词 III - 力扣（LeetCode）

43. 字符串相乘 - 力扣（LeetCode）

标准库中的string类

推荐一个c++函数网站：cplusplus

2.1 string类(了解)

https://cplusplus.com/reference/string/string/?kw=string（可复制链接查看string类）

1. string是表示字符串的字符串类

2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。

3. string在底层实际是：basic_string模板类的别名，typedef basic_string<char,char_traits,allocator>  string;

4. 不能操作多字节或者变长字符的序列。

string类常用接口

1. string类对象的常见构造

void Teststring()
{string s1; // 构造空的string类对象s1string s2("hello jzy"); // 用C格式字符串构造string类对象s2string s3(s2);//拷贝构造s3
}

2. string类对象的容量操作

vs是1.5倍扩容，linux是2倍扩容

vs会多开一点空间，linux说开多少开多少

linux缩容不会删除数据，但是会缩小到size

vs不会缩容

注意：

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

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

4. string类对象的修改操作

注意：

1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般 情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。

2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。

5. string类非成员函数

上面的几个接口大家了解一下，OJ题目中会有一些体现他们的使用。string类中还有一些其他的操作，这里不一一列举，大家在需要用到时不明白了查文档即可。

string类的模拟实现完整代码

已交代完毕，代码无误

string.h

# define _CRT_SECURE_NO_WARNINGS 1
#include<assert.h> 
#include<iostream>using namespace std;namespace jzy
{class string{public: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;}const char* c_str() const{return _str;}size_t size() const{return _size;}string(const char* str = "");// ִдstring(const string& s);string& operator=(string s);~string();const char& operator[](size_t pos) const;char& operator[](size_t pos);void reserve(size_t n);void push_back(char ch);void append(const char* str);string& operator+=(char ch);string& operator+=(const char* str);void insert(size_t pos, char ch);void insert(size_t pos, const char* str);void erase(size_t pos, size_t len = npos);void swap(string& s);size_t find(char ch, size_t pos = 0);size_t find(const char* str, size_t pos = 0);string substr(size_t pos = 0, size_t len = npos);void clear();private:size_t _capacity = 0;size_t _size = 0;char* _str = nullptr;const static size_t npos = -1;};istream& operator>>(istream& in, string& s);ostream& operator<<(ostream& out, const string& s);
}

string.cpp

#define CRT_SECURE_NO_WARNINGS 1
#include"string.h"namespace jzy
{string::string(const char* str)//默认构造给一个空串{_size = strlen(str);_capacity = _size;_str = new char[_capacity + 1];strcpy(_str, str);}//拷贝构造现代写法string::string(const string& s){string tmp(s._str);swap(tmp);}//赋值重载现代写法string& string::operator=(string s){swap(s);return *this;}string::~string(){delete[] _str;_str = nullptr;_size = 0;_capacity = 0;}const char& string::operator[](size_t pos) const{assert(pos <= _size);return _str[pos];}char& string::operator[](size_t pos){assert(pos <= _size);return _str[pos];}void string::reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}}void string::push_back(char ch){if (_size == _capacity){size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newCapacity);}_str[_size] = ch;_size++;_str[_size] = '\0';}void string::append(const char* str){size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}strcpy(_str + _size, str);_size += len;}string& string::operator+=(char ch){push_back(ch);return *this;}string& string::operator+=(const char* str){append(str);return *this;}void string::insert(size_t pos, char ch){assert(pos <= _size);if (_size == _capacity){size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newCapacity);}size_t end = _size + 1;while (end > pos){_str[end] = _str[end - 1];--end;}_str[pos] = ch;_size++;}void string::insert(size_t pos, const char* str){assert(pos <= _size);size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}int end = _size;while (end >= (int)pos){_str[end + len] = _str[end];--end;}strncpy(_str + pos, str, len);_size += len;}void string::erase(size_t pos, size_t len){assert(pos < _size);if (len == npos || pos + len >= _size){_str[pos] = '\0';_size = pos;}else{strcpy(_str + pos, _str + pos + len);_size -= len;}}void string::swap(string& s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}size_t string::find(char ch, size_t pos){for (size_t i = pos; i < _size; i++){if (_str[i] == ch){return i;}}return npos;}size_t string::find(const char* str, size_t pos){const char* ptr = strstr(_str + pos, str);if (ptr == nullptr){return npos;}else{return ptr - _str;}}string string::substr(size_t pos, size_t len){assert(pos < _size);size_t end = pos + len;if (len == npos || pos + len >= _size){end = _size;}string str;str.reserve(end - pos);for (size_t i = pos; i < end; i++){str += _str[i];}return str;}void string::clear(){_size = 0;_str[0] = '\0';}ostream& operator<<(ostream& out, const string& s){for (auto ch : s){out << ch;}return out;}istream& operator>>(istream& in, string& s){s.clear();char buff[128];char ch = in.get();int i = 0;while (ch != ' ' && ch != '\n'){buff[i++] = ch;if (i == 127){buff[i] = '\0';s += buff;i = 0;}ch = in.get();}if (i > 0){buff[i] = '\0';s += buff;}return in;}
}

test.cpp

#define _CRT_SECURE_NO_WARNINGS 1#include"string.h"namespace jzy
{void print_str(const string& s){for (size_t i = 0; i < s.size(); i++){cout << s[i] << " ";}cout << endl;string::const_iterator it = s.begin();while (it != s.end()){cout << *it << " ";++it;}cout << endl;}void test_string1(){string s1("hello world");cout << s1.c_str() << endl;string s2;cout << s2.c_str() << endl;for (size_t i = 0; i < s1.size(); i++){s1[i]++;}cout << s1.c_str() << endl;string::iterator it = s1.begin();while (it != s1.end()){cout << *it << " ";++it;}cout << endl;for (auto ch : s1){cout << ch << " ";}cout << endl;print_str(s1);}void test_string2(){string s1("hello world");cout << s1.c_str() << endl;s1 += ' ';s1 += "xxxxxx";cout << s1.c_str() << endl;s1.insert(5, 'y');s1.insert(5, 'y');s1.insert(5, 'y');cout << s1.c_str() << endl;s1.insert(0, 'y');cout << s1.c_str() << endl;s1.insert(0, "zzzzzzz");cout << s1.c_str() << endl;}void test_string3(){string s1("hello world");cout << s1.c_str() << endl;s1.erase(5, 4);cout << s1.c_str() << endl;s1.erase(5, 100);cout << s1.c_str() << endl;s1.erase(2);cout << s1.c_str() << endl;}void test_string4(){string s1("hello world");string s2("xxxx");std::swap(s1, s2);s1.swap(s2);string str("https://legacy.cplusplus.com/reference/string/string/substr/");string sub1, sub2, sub3;size_t pos1 = str.find(':');sub1 = str.substr(0, pos1 - 0);cout << sub1.c_str() << endl;size_t pos2 = str.find('/', pos1 + 3);sub2 = str.substr(pos1 + 3, pos2 - (pos1 + 3));cout << sub2.c_str() << endl;sub3 = str.substr(pos2 + 1);cout << sub3.c_str() << endl;}void test_string5(){string s1("hello world");string s2(s1);string s3("xxxx");s1 = s3;}void test_string6(){string s1("hello world");string s2(s1);string s3("xxxx");s1 = s3;cout << s1.c_str() << endl;cout << s1 << endl;cin >> s1;cout << s1 << endl;/*char ch1, ch2;cin >> ch1 >> ch2;*/cin >> s2;cout << s2 << endl;}void test_string7(){string s1("hello world");cout << s1.c_str() << endl;cout << s1 << endl;s1.clear();cout << s1.c_str() << endl;cout << s1 << endl;}void test_string8(){string s1("hello world");string s2(s1);cout << s1 << endl;cout << s2 << endl;string s3("xxxxxxxxxxxxxxxx");s1 = s3;cout << s1 << endl;cout << s3 << endl;}
}int main()
{jzy::test_string2();return 0;
}

模拟实现讲解

 默认在.h有缺省值“”，意思是默认构造一个空字符串，string构造，先求出长度赋值给_size，然后容量是有效字符个数，最后_str new出来容量+1的空间，意思是给\0腾出一个空间，这流程下来只用strlen一次，减少时间复杂度的消耗，开好空间最后再拷贝过去

交换有3个，库里的2个，string库里1个，因为默认的swap内置类型没事，自定义类型会深拷贝，所以默认用string类型交换都会转换成调用string库里边的，string库里边默认是调用默认的swap，内置类型直接值交换就行，减少深拷贝的损耗

s1拷贝构造s2，先构造一个tmp，用tmp和s2交换，tmp出作用域调用析构函数，s2会指向拷贝构造完成的新空间

赋值拷贝也很简单，先让s3拷贝构造一下s，交换s和s1，s1指向赋值后新空间，s出作用域调用析构，直接释放空间

析构函数，先delete释放空间，置空，内置类型置0

[]，非const类型调用非const[]，返回可以修改的char&,const类型调用const[]，返回不可修改的const char&

reserve是修改容量， 这里我们只扩容不缩容，申请新空间（多申请一个是给\0，容量是存放有效字符个数），将值拷贝过去，析构_str，_str指向新空间，容量置n

尾插还是老一套，判断是否需要扩容，尾插，size++，将下一个位置置\0（因为每次都会多开一个空间，所以永远不会越界）

这个append是老一套，尾插一个字符串，先判断是否要扩容，在拷贝过去

+=字符很简单，直接复用尾插，返回*this，+=后的结果

+=字符串，复用append逻辑，返回+=后的结果

插入逻辑，和顺序表的随机插入有异曲同工之妙，先向后逐一挪动字符，再在对应位置插入某个字符

任意位置插入字符串，逻辑相似，不再赘述

erase，删除某一个位置长度是len的字符串/字符，如果长度是npos（无符号整数最大值）或者pos+len大于等于有效字符个数，就直接把pos位置和之后的字符全部删除，并且_size置为pos；如果删除的长度小于有效字符个数，将剩余的字符拷贝到pos位置，将_size置为删除长度后的值

从某个位置找某个字符，找到返回这个值的下标，找不到返回npos

利用strstr找到那个字符串，返回下标，找不到返回nops

清理字符串，直接_size是0，第一个位置填充\0就行

流插入（输出），直接范围for（迭代器）打印字符类型，返回字符串

流提取（输入），按照库里边是遇到空格或者换行结束

getline是提取字符串一行，遇到\n结束（遇到空格不结束）

cin是提取字符串遇到空格或者换行结束

代码样例详解

这里是打印string串的2种形式，第一个下标访问打印，第二个用const迭代器，因为参数是const string，记住这两种写法，是遍历的2种形式

打印string，第一个是正常char*类型构造，第二行是无参，空字符串构造

下边是遍历打印，很简单不在赘述

string支持+=字符和字符串，也支持插入某个位置是字符或者字符串

删除，第一个参数是要删除数字下标，第二个参数是长度，不传默认是npos（42亿多）会删完

拷贝构造和赋值拷贝都很简单，模拟实现详解已经讲明白了，不会的可以看看

打印s1用c_str或者s1都行，c_str是char*类型cout自动识别内置类型，s1是因为我们自己写的自定义类型重载，cin两个字符串，遇到换行或者空格结束

清理字符串，需要注意的是，有一种错误情况

如果将下边注释掉，c_str打印_str，没有\0的限制，会打印到最后，相反s1是利用迭代器遍历打印，迭代器end是靠size控制的

，所以打印整个对象没事，要记住clear是将底层有效字符清空，要置\0

这是一个简单的拷贝构造+赋值拷贝，前面讲的很清楚了

最后讲一下字符串切割

substr返回一个新构造的对象，参数第一个是位置，第二个是长度，不传默认切割到最后

find第一个参数是要查找的字符或字符串，第二个参数是起始位置，不传默认从起始位置找，返回值是下标

结果是三个字符串，相信经过我的讲解大家对string的理解更上一层楼

以上就是我对string关键知识的理解，希望能帮到你