为什么学习 string 类？
1.1 C 语言中的字符串
C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可 能还会越界访问。
1.2 面试题
在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本 都使用string类，很少有人去使用C库中的字符串操作函数。
string类oj题
387. 字符串中的第一个唯一字符 - 力扣（LeetCode）
LCR 192. 把字符串转换成整数 (atoi) - 力扣（LeetCode）
标准库中的 string 类
推荐一个c++函数网站：cplusplus
2.1 string 类 ( 了解 )
https://cplusplus.com/reference/string/string/?kw=string（可复制链接查看string类）
string是表示字符串的字符串类
该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
string在底层实际是：basic_string模板类的别名，typedef basic_string<char,char_traits,allocator> string;
不能操作多字节或者变长字符的序列。
string类常用接口
1. string 类对象的常见构造
cpp
void Teststring()
{
string s1; // 构造空的string类对象s1
string s2("hello jzy"); // 用C格式字符串构造string类对象s2
string s3(s2);//拷贝构造s3
}2. string 类对象的容量操作
vs是1.5倍扩容，linux是2倍扩容
vs会多开一点空间，linux说开多少开多少
linux缩容不会删除数据，但是会缩小到size
vs不会缩容
注意：
size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
clear()只是将string中有效字符清空，不改变底层空间大小。
resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
3. string 类对象的访问及遍历操作
4. string 类对象的修改操作
注意：
在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般 情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
5. string类非成员函数
上面的几个接口大家了解一下，OJ题目中会有一些体现他们的使用。string类中还有一些其他的操作，这里不一一列举，大家在需要用到时不明白了查文档即可。
string 类的模拟实现完整代码
已交代完毕，代码无误
string.h
cpp
# 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
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
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关键知识的理解，希望能帮到你