目录

引言

为什么要学习string

1.C语言中的字符串

2.C++中的字符串

auto和范围for

1.auto

1.1 auto的介绍

1.2 注意事项

2.范围for

标准库中的string类

1.string类的迭代器

1.1 begin()与end()函数

1.2 rbegin()与rend()函数

2.string类的初始化和销毁

3.string类的容量操作

3.1 有效长度和容量大小

(1)使用示例

(2)扩容机制

3.2 有效长度和扩容操作

(1)reserve函数

(2)resize函数

(3)clear函数

4.string类的访问操作

4.1 operator[]函数

4.2 at函数

4.3 front 和 back 函数

5.string类的修改操作

5.1 字符串增加操作

5.2 字符串替换操作

5.3 字符串删除操作

5.4 字符串交换操作

5.5 字符串其他操作

结束语

---

引言

为了简化字符串的处理，C++标准库引入了string类。string类是一个模板类，专门用于表示和操作字符串。今天我们来学习一下string。

为什么要学习string

1.C语言中的字符串

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

2.C++中的字符串

为了简化字符串的处理，C++标准库引入了string类。string类是一个模板类，专门用于表示和操作字符串。它不仅封装了字符串的底层细节，如内存分配和释放，还提供了一套丰富而易于使用的成员函数，用于执行各种字符串操作，如拼接、比较、查找、替换、插入和删除等。

下面是一个string的简单使用：

<code>int main()

{

string s1;

string s2("hello world");

string s3(s2);

cout << s1 << endl;

cout << s2 << endl;

cout << s3 << endl;

string s4(s2, 6, 15);

cout << s4 << endl;

string s5(s2, 6);

cout << s5 << endl;

string s6("hello world", 5);

cout << s6 << endl;

string s7(10, 'x');

cout << s7 << endl;

return 0;

}

输出结果为：

下面我们来详细学习一下。

auto和范围for

在学习string类之前，我们先来学习一下auto和范围for，方便我们后面的学习。

1.auto

1.1 auto的介绍

auto 关键字用于自动类型推导。编译器会自动根据初始化表达式来推断变量的类型。这避免了在声明变量时显式指定类型，特别是当类型名称很长或复杂时，auto可以使代码更加简洁。

<code>int main()

{

int i = 0, & ri = i;

auto a = i;//a为int型变量

auto a1 = ri;//a1为int型变量

auto p = &i;// &i 是一个普通int指针，p是一个整型指针int *

auto p1 = &ri;//同上

return 0;

}

1.2 注意事项

(1)使用 auto 声明的变量必须有初始化表达式，否则编译器无法推导其类型。

因此，不能这样子：

auto x;

(2)对于模板实例化、复杂表达式等，auto 能够推导出相应的复杂类型

std::vector<int> vec = {1, 2, 3};

auto v = vec; // v 的类型是 std::vector<int>

auto result = Fun(x, y); // result 的类型由函数返回类型决定

(3)auto也有一些缺陷，例如它降低了代码的可读性，导致我们无法一眼看出变量的类型（像上面的代码，我们不能直观的看出 v 的类型）。

(4)用 auto 声明指针类型时，用 auto 和 auto* 没有任何区别，只是 auto* 必须是指针。但是用 auto 声明引用类型时，必须加 & 。

int x = 1;

auto a = &x;

auto* b = &x;

auto& c = x;

2.范围for

范围for（也称为基于范围的for循环）是C++11引入的一种新的循环语法，用于简化对容器（如vector、list、map等）、数组或初始化列表中的元素进行遍历的操作。这种循环语法使得代码更加简洁、清晰，提高了代码的可读性和可维护性。

范围for循环的基本语法如下：

for (元素类型 变量名 : 容器或数组名)

{

// 循环体

}

来看个简单的例子：

int main()

{

int arr[] = { 1,2,3,4,5 };

for (auto i : arr)

{

cout << i << endl;

}

return 0;

}

输出结果为：

由于 i 是临时变量，不能直接修改数组元素的值，我们需要使用引用 & 。

<code>int main()

{

int arr[] = { 1, 2, 3, 4, 5 };

for (auto& i : arr) // 注意这里使用了引用&

{

i *= 2; // 修改数组元素的值

cout << i << endl;

}

return 0;

}

输出结果为：

标准库中的string类

我们可以使用以下文档来辅助我们学习string：

string类的接口详细介绍

1.string类的迭代器

迭代器（Iterator）在C++中是一种抽象化的概念，它提供了一种统一的方法来遍历容器中的元素，而无需了解容器内部的具体实现细节。

迭代器在行为上类似于指针，但它不仅仅局限于原始指针的功能。迭代器封装了对容器元素的访问，并且根据容器的不同，迭代器可以有不同的实现。然而，从用户的角度来看，迭代器提供了一种统一的接口来遍历容器，这使得代码更加通用和可移植。

当我们使用迭代器时，确实可以将其当作指针来使用，但需要注意的是，迭代器并不是指针的替代品，而是对容器遍历操作的一种抽象。

在 string 类中，我们就可以通过迭代器来访问其具体元素，并且也为我们提供了相应的调用函数。

1.1 begin()与end()函数

迭代器提供了 begin() 和 end() 成员函数，用于获取遍历的起始位置和结束位置。

begin()与end()函数的使用方法具体如下：

begin():

函数声明：

对于非const的std::string对象，iterator begin(); 返回指向第一个字符的iterator。

对于const的std::string对象，const_iterator begin() const; 返回指向第一个字符的const_iterator。

作用：返回指向字符串第一个字符的迭代器。

返回值：

对于非const对象，返回iterator，允许通过迭代器修改字符串中的字符。

对于const对象，返回const_iterator，仅允许通过迭代器读取字符串中的字符，不允许修改。

end() :

函数声明（对于std::string）：

iterator end(); 返回指向字符串末尾（即最后一个字符之后的位置）的iterator。

const_iterator end() const; 对于const对象，返回指向字符串末尾的const_iterator。

作用：返回指向字符串末尾（即最后一个字符之后的位置）的迭代器。这个迭代器通常用作遍历循环的结束条件。

我们来尝试使用一下这俩玩意，代码如下：

<code>int main()

{

string s1("hello world");

cout << s1 << endl;

string::iterator it = s1.begin();

while (it != s1.end())

{

cout << *it << " ";

++it;

}

cout << endl;

return 0;

}

输出结果为：

<code>int main()

{

const string s2("hello world");

cout << s2 << endl;

// const迭代器，用于遍历const字符串，不能改变字符串中的值

string::const_iterator it = s2.begin();

while (it != s2.end())

{

cout << *it << " ";

++it;

}

cout << endl;

return 0;

}

输出结果为：

1.2 rbegin()与rend()函数

rbegin：

函数声明（对于 std::string 和其他支持反向迭代器的容器）： 

reverse_iterator rbegin();    

const_reverse_iterator rbegin() const;

作用：

返回指向容器（如 std::string）中最后一个元素（即反向遍历的起始位置）的反向迭代器。这使得可以反向遍历容器中的元素。

返回值：

对于非 const 容器，返回 reverse_iterator。对于 const 容器，返回const_reverse_iterator。

rend：

函数声明（对于 std::string 和其他支持反向迭代器的容器）：

reverse_iterator rend();

const_reverse_iterator rend() const;

作用：

返回指向容器（如 std::string）中第一个元素前面一个位置的反向迭代器。这实际上是反向遍历的结束位置，它不指向任何有效元素，而是作为反向遍历的结束标志。

返回值：

对于非 const 容器，返回 reverse_iterator。 对于 const 容器，返回 const_reverse_iterator。

来简单的使用一下：

<code>int main()

{

string s1("hello world");

cout << s1 << endl;

string::reverse_iterator rit = s1.rbegin();

while (rit != s1.rend())

{

cout << *rit << " ";

++rit;

}

cout << endl;

return 0;

}

输出结果为：

<code>int main()

{

const string s2("hello world");

cout << s2 << endl;

string::const_reverse_iterator rit = s2.rbegin();

while (rit != s2.rend())

{

cout << *rit << " ";

++rit;

}

cout << endl;

return 0;

}

输出结果为：

2.string类的初始化和销毁

由于 string 是一个类，因此我们在初始化时肯定会调用其构造函数初始化。

(1)默认构造函数:创建一个空的字符串对象。

(2)拷贝构造函数:创建一个新的字符串对象，它是另一个字符串对象的副本。这允许通过现有的字符串来初始化新字符串。

(3)子字符串构造函数:创建一个新的字符串对象，它是另一个字符串对象从pos位置开始、长度为len的子串。如果len是npos（默认情况），则子串从pos开始直到原字符串的末尾。

(4)从C字符串构造函数:使用C风格的字符串（以空字符'\0'结尾的字符数组）来初始化字符串对象。

(5)从C字符串的前n个字符构造函数:使用C风格的字符串的前n个字符来初始化字符串对象。

(6)填充构造函数:创建一个新的字符串对象，其中包含n个重复的字符c。

(7)范围构造函数:这是一个模板构造函数，允许使用任何输入迭代器对（如指针、std::vector的迭代器等）来初始化字符串。它复制从first到last（不包括last）范围内的所有元素到新的字符串对象中。

(1)字符串赋值:这个重载版本允许将一个 std::string 对象的内容赋值给另一个 std::string 对象。这是通过复制 str 的内容到当前对象来实现的。注意，这里使用了引用传递（const string&），这有助于避免不必要的复制，提高效率。

(2)C风格字符串赋值:这个重载版本允许将一个C风格字符串（即以空字符（'\0'）结尾的字符数组）赋值给 std::string 对象。std::string 会复制 s 指向的C风格字符串的内容（不包括结尾的空字符），并存储在自己的内部表示中。

(3)单个字符赋值:这个重载版本允许你将一个单独的字符赋值给 std::string 对象。这通常会导致 std::string 对象的内容被替换为仅包含该字符的一个新字符串。

下面是代码演示：

<code>int main()

{

// (1)默认构造函数。

string s1;

s1 = "hello world!";

//(2)拷贝构造函数

string s2(s1);

//(3)子字符串构造函数

string s3(s2, 1, 7);

//(4)从C字符串构造函数

string s4("hello world!");

//(5)从C字符串的前n个字符构造函数

string s5("hello world!", 5);

//(6)填充构造函数

string s6(7, 'a');

//(7)范围构造函数

string s7(s1.begin(), s1.end());

// 赋值运算符重载初始化

string s8 = "hello world!";

cout << s1 << endl;

cout << s2 << endl;

cout << s3 << endl;

cout << s4 << endl;

cout << s5 << endl;

cout << s6 << endl;

cout << s7 << endl;

cout << s8 << endl;

return 0;

}

输出结果为：

在C++中，std::string 是一个类模板的实例化，代表了一个可变的字符序列。由于它是一个类，当 std::string 对象的生命周期结束时（即离开其作用域），编译器会自动调用该对象的析构函数来清理其分配的资源。

3.string类的容量操作

在C++中，std::string 类提供了多种与容量（capacity）相关的操作，这些操作允许你查看或修改字符串的内部存储空间的大小。

以下是比较常见的容量操作：

函数名称	功能
size	返回字符串的有效长度
length	返回字符串的有效长度
capacity	返回字符串的容量大小
max size	返回字符串的最大长度
clear	清空字符串
empty	检查是否为空串，是则返回true，否则返回false
reserve	请求改变字符串的容量
resize	重新设置有效字符的数量，超过原来有效长度则用c字符填充

3.1 有效长度和容量大小

(1)使用示例

std::string 的容量（capacity）并不总是等于其当前长度（size）。容量是字符串为了存储更多字符而预先分配的内存量，而长度是当前存储在字符串中的字符数。

我们通过代码来验证一下：

<code>int main()

{

string s("hello world");

cout << s.size() << endl;//有效长度

cout << s.length() << endl;//有效长度

cout << s.capacity() << endl;//容量大小

cout << s.max_size() << endl;//最大大小

return 0;

}

输出结果为：

其中有效长度 size 以及容量大小 capacity 不包括\0。而 max_size 返回字符串最大容量，不同平台下大小可能不一样。

还有一个判空函数empty()，下面是一个简单的使用示例：

<code>int main()

{

string s1("");

string s2("hello world");

if (s1.empty())

{

cout << "s1为空串" << endl;

}

else

{

cout << "s1不为空串" << endl;

}

if (s2.empty())

{

cout << "s2为空串" << endl;

}

else

{

cout << "s2不为空串" << endl;

}

return 0;

}

输出结果为：

(2)扩容机制

我们接下来研究一下string的扩容机制：

来看看这段代码：

<code>int main()

{

string s;

size_t sz = s.capacity();

cout << "making s grow:\n";

for (int i = 0; i < 100; ++i)

{

s.push_back('c');

if (sz != s.capacity())

{

sz = s.capacity();

cout << "capacity changed: " << sz << '\n';

}

}

return 0;

}

输出结果为：

我们可以看到，在vs2022中，string大致以一点五倍进行扩容处理。我们来看看在g++编译器的运行结果：

我们可以看到，在这里是二倍扩容处理。

3.2 有效长度和扩容操作

我们先来学习两个可以改变容量的函数 reserve，resize。

(1)reserve函数

reserve函数用于请求改变字符串的容量（capacity），即为其内部存储空间分配至少能容纳n个字符的空间。

来测试一下：

<code>int main()

{

string s1;

s1.reserve(50);

cout << s1.capacity() << endl;

return 0;

}

输出结果为：

系统开辟的空间往往是大于程序员设定的空间的，且遵循对齐原则。

(2)resize函数

resize函数用于改变字符串的大小（size），即改变其中包含的字符数。

如果 n 小于当前字符串的长度，则 resize 函数会将字符串缩短到前 n 个字符，并删除超出第 n 个字符之后的所有字符。

如果 n 大于当前字符串的长度，则 resize 函数会扩展字符串，以便它能够包含 n 个字符。这通常涉及到在字符串的末尾添加新的字符。

如果调用时提供了第二个参数 c，则这些新添加的字符将被初始化为 c 的副本。

如果没有提供第二个参数 c，则新添加的字符是值初始化的。

n<size:

测试代码：

<code>void test1()

{

string s1 = "hello world";

cout << "字符个数：" << s1.size() << endl;

cout << "空间大小：" << s1.capacity() << endl << endl;

s1.resize(10);

cout << "修改后字符个数：" << s1.size() << endl;

cout << "修改后空间大小：" << s1.capacity() << endl;

}

输出结果：

size < n < capacity:

测试代码：

<code>void test2()

{

string s1 = "hello world";

cout << "字符个数：" << s1.size() << endl;

cout << "空间大小：" << s1.capacity() << endl << endl;

s1.resize(12);

cout << "修改后字符个数：" << s1.size() << endl;

cout << "修改后空间大小：" << s1.capacity() << endl;

}

输出结果为：

n>capacity:

测试代码：

<code>void test3()

{

string s1 = "hello world";

cout << "字符个数：" << s1.size() << endl;

cout << "空间大小：" << s1.capacity() << endl << endl;

s1.resize(20);

cout << "修改后字符个数：" << s1.size() << endl;

cout << "修改后空间大小：" << s1.capacity() << endl;

}

输出结果：

(3)clear函数

string 类提供的 clear 函数用于移除字符串中的所有字符，使其变为空字符串。

下面是个简单的测试：

<code>int main()

{

string str = "Hello, World!";

// 检查字符串是否为空

if (str.empty())

{

cout << "串为空" << endl;

}

else

{

cout << "串不为空" << endl;

}

// 清除字符串

str.clear();

// 检查字符串是否为空

if (str.empty())

{

cout << "串为空" << endl;

}

else

{

cout << "串不为空" << endl;

}

// 输出清空后的字符串

cout << "清空后的字符串: " << str << endl;

return 0;

}

输出结果为：

4.string类的访问操作

string类的访问操作通常有如下几种：

函数名称	功能
operator[]	返回指定位置的字符，越界则报错
at	返回指定位置的字符，越界则抛异常
back	返回字符串最后一个字符(不是"0”)
front	返回字符串第一个字符

4.1 operator[]函数

string类的operator[]函数是一个重载的下标操作符，它允许通过索引来访问字符串中的单个字符。

string 类重载了两个operator[]，一个是普通版的，一个是 const ，即字符串不可修改的。

简单的测试：

<code>int main()

{

string s1 = "hello world";

cout << s1[0] << endl;

cout << s1[2] << endl;

cout << s1[4] << endl;

return 0;

}

输出结果为：

普通版的话我们可以对字符串进行修改。

<code>int main()

{

string s1 = "hello world";

s1[0] = 'x';

s1[1] = 'x';

s1[2] = 'x';

cout << s1 << endl;

return 0;

}

输出结果为：

4.2 at函数

at函数提供了一种安全的方式来访问字符串中的字符。与operator[]不同，at函数会执行范围检查，以确保提供的索引没有超出字符串的当前长度。

<code>int main()

{

string s1("hello world");

cout << s1.at(0) << endl;

cout << s1.at(2) << endl;

return 0;

}

输出结果为：

4.3 front 和 back 函数

这两个用的比较少，了解即可。

<code>int main()

{

string s1("hello world");

cout << s1.front() << endl;

cout << s1.back() << endl;

return 0;

}

输出结果如下：

5.string类的修改操作

关于string类的操作修改的接口比较多，由于篇幅有限，实在不能详细一个个讲解，我们就先学习一些比较重要的，其他的有需要再去了解。

函数名称	功能说明
push_back	在字符串后尾插字符c
append	在字符串后追加一个字符串
operator+=	在字符串后追加字符串str
assign	使用指定字符串替换原字符串
replace	用新字符串替换原字符串指定区间
pop_back	删除字符串最后一个字符
erase	删除字符串指定部分
swap	交换两个字符串

5.1 字符串增加操作

字符串的增加操作，在末尾添加字符可以使用push_back，在末尾添加字符串可以使用append，而operator+=既可以在末尾添加字符，也可以添加字符串。

<code>int main()

{

string str("hello world");

// 追加一个！

str.push_back('!');

cout << str << endl;

str += '!';

cout << str << endl;

// 在字符串开头插入一个'!'

str.insert(0, 1, '!');

cout << str << endl;

// 追加一个字符串

str.append("hello ");

cout << str << endl;

str += "world!";

cout << str << endl;

return 0;

}

输出结果为：

5.2 字符串替换操作

字符串替换操作我们用到的是assign和replace。

assign是直接替换掉原字符串，而replace是替换原字符串的某段区间。

示例如下：

<code>int main()

{

std::string s1("hello world");

std::string s2;

s2.assign(s1);

std::cout << s2 << std::endl;

s2.assign(s1, 6);

std::cout << s2 << std::endl;

// 用s1替换掉下标为2，长度为2的区间

std::string s3("ciallo");

s3.replace(2, 2, s1);

std::cout << s3 << endl;

}

输出结果：

这俩函数接口比较多，可以自行查看文档进行学习。

5.3 字符串删除操作

pop_back支持删除最后一个字符，erase支持删除任意区间。

<code>int main()

{

string str("hello world");

str.pop_back();

cout << str << endl;

str.erase(str.begin());

cout << str << endl;

str.erase(0, 2);

cout << str << endl;

return 0;

}

输出结果为：

5.4 字符串交换操作

swap 函数用于交换两个字符串对象的内容。

<code>int main()

{

string s1("hello world");

string s2("C++");

cout << s1 << endl;

cout << s2 << endl;

s1.swap(s2);

cout << s1 << endl;

cout << s2 << endl;

return 0;

}

输出结果为：

5.5 字符串其他操作

除了以上这些，string类还有很多可以使用的操作。

函数名称	功能
c_str	返回C格式的字符串
substr	从字符串pos位置开始，截取n个字符，然后将其返回
find	从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
rfind	从字符串pos位置开始往前找字符c，返回该字符在字串中的位置
find_first_ of	在原字符串中，从前往后找匹配串中第一个匹配的字符
find_last_of	在原字符串中，从后往前找匹配串中第一个匹配的字符
find_first_not of	在原字符串中，从前往后找匹配串中第一个不四配的字符
find_last_not_ of	在原字符串中，从后往前找匹配串中第一个不匹配的字符
getline	获取一行字符串
operator+	尽量少用，因为传值返回，导致深拷贝效率低
operator<<	流提取重载
operator>>	流插入重载

下面就不展开说了，可以通过查看文档来进行学习。

结束语

本篇博客写的有点长了。。。

希望能对各位大佬有所帮助！！！

求点赞收藏评论关注！！！

感谢各位！！！