个人主页：K 旺仔小馒头
学习方向：C/C++方向学习者
个人专栏：《C语言》《数据结构与算法》《C++知识分享》《C语言实战编程》
⭐️人生格言：“何时葡萄先熟透，你要静候再静候”
目录
1.3.2 max_size、capacity、clear（重点）
前言：
C++ string类是文本处理领域的基石，却因繁多接口与底层机制常令开发者困扰。本文聚焦其构造、访问、容量管理与修改操作四大维度，以代码示例深度解析operator[]、迭代器等核心访问方式，详解reserve/resize扩容策略，还融入C++11 auto与范围for语法，助你吃透string类，避开使用误区。
标准库中的string类：
string这个容器，它是一个basic_string的类模板，平时用string就行（它是被typedef出来的）
平时用string，要包一个头文件#include <string>
注意：
C++兼容C语言，所以字符串后面是有\0的
空的string底层也有\0，但\0不算有效字符
自定义类型要用输入、输出是需要重载运算符的
因为string重载了流插入、流提取，所以string是直接可以用cin、cout进行输入、输出
1. string类的接口说明
1.1 string类对象的构造
知识点：
1.string也可以用常量字符串来构造（第4点），给一个字符串数组的指针
常量字符串本质上是字符数组，数组传参会转换成指针
2. npos：npos属于类域，string定义的const静态成员变量
不传npos，就会拷贝到结尾
常见构造：
void Teststring()
{
string s1; //构造空的string类对象s1
string s2("hello bit"); //用C格式字符串构造string类对象s2
string s3(s2); //拷贝构造s3
}string类对象的析构：
构造是很重要的，析构不重要（我们要了解析构的功能，但是它不重要，因为它自动调用）
string类对象的赋值：
赋值和拷贝构造都涉及深拷贝这个底层
代码演示：（这里也有些不常见的，注意甄别）
#include
#include
using namespace std;
void test_string1()
{
string s1;
string s2("hello world");
string s3(s2);
cout << s1 << endl;//打印是不会把\0打印出来的
cout << s2 << endl;
cout << s3 << endl;//string底层的拷贝涉及到深拷贝、浅拷贝的问题
string s4(s2, 0, 5);
cout << s4 << endl;
//pos位置拷贝到结尾
string s5(s2, 6, 15);//不会报错
cout << s5 << endl;
string s6(s2, 6);//不传第二个字符,就会拷贝到结尾
cout << s6 << endl;
string s7("hello world", 6);//想用它的前6个
cout << s7 << endl;
string s8(10, '*');//想用10个*
cout << s8 << endl;
s7 = "xxxx";//用常量字符串来赋值
cout << s7 << endl;
}
int main()
{
test_string1();
return 0;
} 1.2 string类对象的访问及遍历操作
1.2.1 operator[]（重点）
知识点：
它是为了让我们的对象像数组一样去使用，string、vector它们底层都是数组
这里的pos就是下标
//string的内部逻辑实现:
class string
{
public:
char& operator[] (size_t pos) //char&能修改返回对象
{
return _str[pos];//返回pos位置的字符
}
private:
char* _str;
size_t _size;//表示有多少个字符,不包含\0
size_t capacity;//容量
};代码演示：
#include
#include
using namespace std;
void test_string2()
{
string s1("hello world");
cout << s1 << endl;
s1[0] = 'x';
cout << s1 << endl;
cout << s1[0] << endl;//返回的是char&,也就意味着既能读，也能写
//越界有严格的断言检查(断言是直接终止掉程序)
s1[12];//越界会报错滴~,越界读它也会报错
}
int main()
{
test_string2();
return 0;
} 1.2.2 at
at和[]的功能是一样的，唯一的区别：它们对错误处理的方式不同，如果越界了，at会抛异常，[]会断言
嫌断言（直接终止掉程序）太激烈了，可以用at（抛异常，可以被捕获，至少程序不会终止）
#include
#include
using namespace std;
void test_string2()
{
string s1("hello world");
cout << s1 << endl;
s1[0] = 'x';
cout << s1 << endl;
cout << s1[0] << endl;
//越界,抛异常
s1.at(12);//异常被捕获后,可以读,也可以修改
}
int main()
{
try
{
test_string2();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
} 1.2.3 迭代器（重点）
迭代这个词本身就是用来遍历的
string::iterator it1 = s1.begin();
在string这个类域里面有iterator的一个类型（iterator：迭代器类型）
在一个类域里面还有一个类型，无非就两种：
1. 内部类
2. 在内部进行typedef出来的
知识点：
begin：开始位置的迭代器（第一个有效数据）
end：最后一个字符的下一个位置，就是指向\0的位置（\0不算有效字符）
最后的\0叫标识字符，标识字符串的结束
它俩本质上构成一个左闭右开的区间 -> [begin,end)
list是个链表，它是用模板实现的
所有容器都有迭代器
所有容器内部都有一个iterator的成员（内嵌）类型
#include
#include
#include
using namespace std;
void test_string2()
{
string s1("hello world");
cout << s1 << endl;
s1[0] = 'x';
cout << s1 << endl;
cout << s1[0] << endl;
cout << s1.size() << endl;//推荐
cout << s1.length() << endl;
//下标+[] -> 它不是通用的
//遍历 or 修改
for (size_t i = 0; i < s1.size(); i++)
{
s1[i]++;
}
cout << s1 << endl;
//迭代器用起来行为像指针一样的东西(迭代器不能等价于指针,只是行为像指针) -> 它是所有容器都通用的
string::iterator it1 = s1.begin();//iterator是typedef出来的
while (it1 != s1.end())
{
//(*it1)--;//修改(迭代器除了可以读,也可以写)
cout << *it1 << " ";
++it1;
}
cout << endl;
//遍历链表,这个没有[]就不能加[]了,只能用迭代器
list lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
list::iterator lit = lt.begin();
while (lit != lt.end())
{
cout << *lit << " ";
++lit;
}
cout << endl;
}
int main()
{
test_string2();
return 0;
}
知识点：
迭代器有普通版本，也有const版本
const对象只能读，普通对象可以读可以写
//const就要返回const迭代器
//const迭代器的特点是不能修改
void Print(const string& s)
{
//const string::iterator it1 = s.begin();//error
string::const_iterator it1 = s.begin();//这么写是对的
while (it1 != s.end())
{
//*it1 = 'x';//不能修改
cout << *it1 << " ";
++it1;
}
cout << endl;
}除了 begin、end 这两种迭代器还有两种迭代器需要了解一下：
上面iterator是正向迭代器，它的遍历是从前到后的
还有一个迭代器叫反向迭代器（rbegin、rend），倒着遍历
void Print(const string& s)
{
string::const_reverse_iterator it2 = s.rbegin();
while (it2 != s.rend())
{
//*it2 = 'x';//不能修改
cout << *it2 << " ";
++it2;
}
cout << endl;
}从底层实现的角度思考：迭代器的实现一定是依赖于指针实现的
cbegin、cend 是C++11增加的版本（更规范一点点），跟（const）begin、（const）end是一样的，平时用begin、end就可以
不同容器的迭代器虽然使用上没区别，但是底层原理各种方面还是有很大区别的
迭代器最大的特点：
1. 提供统一的方式遍历修改容器
2. 算法可以泛型化，算法借助迭代器处理容器的数据
（迭代器也是算法和容器之间的桥梁）
STL里的算法，通用算法都写到了算法的头文件 #include <algorithm>
通用的查找算法：
在算法里面迭代区间一定是左闭右开的
代码演示：
string::iterator ret1 = find(s1.begin(), s1.end(), 'x');
if (ret1 != s1.end())
{
cout << "找到了x" << endl;
}
list::iterator ret2 = find(lt.begin(), lt.end(), 2);
if (ret2 != lt.end())
{
cout << "找到了2" << endl;
} 1.2.4 auto和范围for
auto关键字
在这里补充2个C++11的小语法，方便我们后面的学习。
- 在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，后来这个 不重要了。C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型 指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期 推导而得。
- 用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
- 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际 只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
- auto不能作为函数的参数，可以做返回值，但是建议谨慎使用
- auto不能直接用来声明数组
auto会通过右边的值自动推导它的类型，但是auto降低了程序的可读性
注意：
auto不要满天飞
//C++11才有的语法:
void test_string3()
{
int i = 0;
//通过初始化表达式值类型自动推导对象类型
auto j = i;
auto k = 10;
//auto也可以推导指针
auto p1 = &i;//这样写右边可以传指针,也可以不传指针
auto* p2 = &i;//这样写指定一定是指针 p1、p2推导出来都是指针,并且是一样的
cout << p1 << endl;
cout << p2 << endl;
//引用
int& r1 = i;
auto r2 = r1;//r2不是int&引用,是int(这个只能推出int,不能推出引用)
auto& r3 = r1;//r3是int&引用(想推导出引用,得这么写)
cout << &r2 << endl;
cout << &r1 << endl;
cout << &i << endl;
cout << &r3 << endl;
//string::iterator ret1 = find(s1.begin(), s1.end(), 'x');
auto ret1 = find(s1.begin(), s1.end(), 'x');
if (ret1 != s1.end())
{
cout << "找到了x" << endl;
}
//list::iterator ret2 = find(lt.begin(), lt.end(), 2);
auto ret2 = find(lt.begin(), lt.end(), 2);
if (ret2 != lt.end())
{
cout << "找到了2" << endl;
}
}
int main()
{
test_string3();
return 0;
} 范围for：
- 对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。
- 范围for可以作用到数组和容器对象上进行遍历
- 范围for的底层很简单，容器遍历实际就是替换为迭代器，这个从汇编层也可以看到。
所有的容器都可以用范围for
所以我们有三种遍历方式（对于string）：
1. 下标+[]
2. 迭代器
3. 范围for
//C++11(现代C++)
//范围for(遍历)
//自动取容器数据赋值,自动迭代++,自动判断结束
//这个语法很多地方也把它叫做"语法糖"
//for (auto ch : s1)
for (char ch : s1) //遍历string ch是随便取的
{
cout << ch << ' ';
}
cout << endl;
for (auto e : lt) //遍历链表 这里面的auto不是必须用的(只是习惯去用auto,不用auto也可以)
{
cout << e << ' ';
}
cout << endl;用范围for要注意一下：
1. 如果你不修改它的数据，你就这样写
for (char ch : s1)
{
cout << ch << ' ';
}
cout << endl;
for (auto e : lt)
{
cout << e << ' ';
}
cout << endl;2. 如果你要修改，就要加个&（引用）
for (auto& ch : s1)
{
ch -= 1;
}
cout << endl;3. 如果你不修改，但是这个对象比较大，你不想让这个地方产生拷贝，你用引用，但尽量加上const -> 就是加const &
for (const auto& ch : s1)
{
cout << ch << ' ';
}
cout << endl;范围for底层的原理是迭代器
补充：
//支持迭代器的容器,都可以用范围for
//数组也支持(特殊处理)
int a[10] = { 1,2,3 };
for (auto e : a)
{
cout << e << " ";
}
cout << endl;以上总结：
迭代器 可以遍历可以修改
范围for 可以遍历可以修改
[]+下标 可以遍历可以修改，at 也可以遍历可以修改
1.3 string类对象的容量操作
注意：
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不会改变容量大小。
1.3.1 size（重点）和length
知识点：
size和length是一样的（随便用，一般建议用size），没有区别，都是返回长度
注意：虽然它们后面是有\0的，但它俩都不包含\0
#include
#include
using namespace std;
void test_string2()
{
string s1("hello world");
cout << s1 << endl;
s1[0] = 'x';
cout << s1 << endl;
cout << s1[0] << endl;
cout << s1.size() << endl;//推荐
cout << s1.length() << endl;
//遍历 or 修改
for (size_t i = 0; i < s1.size(); i++)
{
s1[i]++;
}
cout << s1 << endl;
}
int main()
{
test_string2();
return 0;
} 1.3.2 max_size、capacity、clear（重点）
知识点：
1.
max_size 返回这个string到底最大能有多长
这个接口是一个没有意义的接口
2. capacity：容量
size和capacity都不包含\0，但是它俩都有\0
3. clear就是把数据给清掉了（数据清到0，\0就挪到前面去了），但是不会清空间
也就是说size变成0，capacity不会变
代码演示：
void test_string4()
{
string s1("hello world");
cout << s1.max_size() << endl;//max_size这个接口是一个没有意义的接口
cout << s1.size() << endl;//不包含结尾的\0
cout << s1.capacity() << endl;//存储实际有效字符个数,不包含结尾的\0
s1.clear();
cout << s1.size() << endl;
cout << s1.capacity() << endl;
}
int main()
{
test_string4();
return 0;
}1.3.3 empty（重点）
empty：判断是否为空
string扩容：
Modifiers：修改的意思
1. 插入
push_back -> 尾插
void TestCapacity()
{
string s1;
size_t old = s1.capacity();
cout << s1.capacity() << endl;
for (size_t i = 0; i < 200; i++)
{
s1.push_back('x');
if (s1.capacity() != old)
{
cout << s1.capacity() << endl;
old = s1.capacity();
}
}
}string扩容的方式：
vs2022 1.5倍扩容（除了第一次） gcc：（2倍扩容）
STL设计是一种规范
规定哪些容器和算法，要实现哪些接口，不同的编译平台实现是不一样的
1.3.4 reserve（重点）
reserve：保留的意思
reverse：颠倒，反转的意思
不要把它俩弄混
reserve：请求capacity的变化，它就是一个手动扩容的接口
你给n，就会把容量扩到n那么大，甚至比n还大（至少得到n）
代码演示：
string s2("hello world");
cout << s2.size() << endl;
cout << s2.capacity() << endl;
s2.reserve(20);//capacity增长至少到20或者比20大,都行
cout << s2.size() << endl;
cout << s2.capacity() << endl;
s2.reserve(5);//capacity有可能会变,有可能不会变,但是它肯定不会到5(因为不能改变内容)
cout << s2.size() << endl;
cout << s2.capacity() << endl;
g++确实在这缩容了 vs2022下就没缩容
它们扩容都是可以扩的，但是不确定是否会缩容
reserve有可能会缩容，但是不要用reserve尝试去缩容
void TestCapacity() //reserve的核心作用就是解决这里的问题
{
string s1;
s1.reserve(200);//确定知道要插入多少字符,用reserve提前扩容
size_t old = s1.capacity();
cout << s1.capacity() << endl;
for (size_t i = 0; i < 200; i++)
{
s1.push_back('x');//提前扩容的话,这儿就不会扩容了，就提高了效率
if (s1.capacity() != old)
{
cout << s1.capacity() << endl;
old = s1.capacity();
}
}
cout << endl << endl;
}不知道要插入多少数据，就不要用reserve
真要缩容，这个shrink_to_fit 接口就是缩容的一个接口（也不会改变内容），不确定缩到跟size一样大
s2.shrink_to_fit();//缩容,一般不要用,代价不小
cout << s2.size() << endl;
cout << s2.capacity() << endl;但是一般情况下，不建议缩容
本质上，缩容是一种经典的以时间换空间的逻辑
扩容、缩容是不影响它里面的数据的
1.3.5 resize（重点）
resize是对size进行一个改变，这个就不涉及容量的问题，主要是要改变它里面的数据
resize既可以插入也可以删除，甚至还会扩容
string s3("hello world");
cout << s3 << endl;
// <当前对象的size,相当于保留前n个,删除后面的数据
s3.resize(5);
cout << s3 << endl;
// >当前对象的size,插入数据
s3.resize(10, 'x');
cout << s3 << endl;
s3.resize(30, 'y');//扩容了
cout << s3 << endl;resize在string部分用的不是很多，但是在vector（顺序表）用的就很多
1.4 string类对象的修改操作
注意：
1. 在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
1.4.1 append
append：追加的意思
最常用的是第3个版本
void test_string5()
{
string s1("hello world");
s1.push_back('%');//插入一个字符,用push_back
s1.append("hello wangzai");//插入多个字符,用append
cout << s1 << endl;
s1.append(10, '#');
cout << s1 << endl;
string s2(" apple hello!");
//s1.append(s2);
s1.append(++s2.begin(), --s2.end());
cout << s1 << endl;
}
int main()
{
test_string5();
return 0;
}1.4.2 operator+=（重点）
因为+=返回的是自己，所以可以用&（引用）返回
//+= 有点像拼接字符串
string s3("hello world");
s3 += ' ';
s3 += "hello wangzai";
cout << s3 << endl;
+ 没有重载为成员函数，重载成了非成员函数（重载成了全局的），+是以传值的方式返回（+是不改变自己的）
成员函数string一定在第一个位置，要是+重载为成员函数，它就做不了以下的事情：
cout << s3 + "xxxx" << endl;
cout << "xxxx" + s3 << endl;顺便说一下：
比较大小也是一样的，是按ASCII来比较的，没有重载为成员函数，重载成了非成员函数（重载成了全局的）
assign也是一种赋值
s3.assign("yyy");//赋值
cout << s3 << endl;pop_back：尾删
1.4.3 insert
insert：头插
insert要谨慎使用，效率不太高（因为要挪动数据）
string s1("hello world");
cout << s1 << endl;
s1.insert(0, "xxx");
cout << s1 << endl;
s1.insert(0, 1, '#');//在0位置插入一个#
cout << s1 << endl;
s1.insert(5, 1, '#');//在第5个位置插入一个#,在哪个位置插入只要不越界都是可以的
cout << s1 << endl;
s1.insert(s1.begin(), '$');
cout << s1 << endl;1.4.4 erase
erase：头删
string s2("hello world");
cout << s2 << endl;
s2.erase(s2.begin());//头删
cout << s2 << endl;
s2.erase(0, 1);//头删
cout << s2 << endl;
s2.erase(5, 2);
cout << s2 << endl;
s2.erase(5);//不传npos,就会删到结尾(跟上面讲的npos是一样的)
cout << s2 << endl;1.4.5 replace
replace：替换
少量用是没问题的，但是要谨慎使用，replace效率不高（因为它也要挪动数据）
string s3("hello world");
cout << s3 << endl;
s3.replace(5, 1, "%%%");
cout << s3 << endl;
s3.replace(5, 3, "*");
cout << s3 << endl;1.4.6 find + npos（重点）
find -> 找
如果没有匹配，它就会返回npos
//所有空格替换为%%
//这个方法效率很低
string s4("hello world hello wangzai");
cout << s4 << endl;
size_t pos = s4.find(' ');//默认从0的位置开始找
while (pos != string::npos)
{
s4.replace(pos, 1, "%%");
//找下一个空格
pos = s4.find(' ', pos + 2);
}
cout << s4 << endl;
//这个方法效率很高
string s5("hello world hello wangzai");
cout << s5 << endl;
string s6;
s6.reserve(s5.size());
for (auto ch : s5)
{
if (ch != ' ')
{
s6 += ch;
}
else
{
s6 += "%%";
}
}
cout << s6 << endl;
//s5 = s6;//赋值结尾：
往期精选：
《吃透C++内存管理：new/delete底层原理与 malloc/free 深度对比全解析》
《别再重复写代码！C++模板初阶：一个模板适配多种数据类型》
结语：通过对string类构造、访问、容量与修改的系统剖析，以及代码示例与编译器差异的对比，我们不仅掌握了其使用技巧，更理解了迭代器的通用价值与C++11语法的便捷性。希望本文对string类的全方位解读，能成为你在文本处理场景中高效开发的实用参考，助你在C++字符串操作中从容应对各类需求。
浙公网安备 33010602011771号