C++——string的了解和使用

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可以使代码更加简洁。

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 是临时变量，不能直接修改数组元素的值，我们需要使用引用 & 。

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。

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

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

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;
}

输出结果为：

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。

来简单的使用一下：

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;
}

输出结果为：

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 对象的内容被替换为仅包含该字符的一个新字符串。

下面是代码演示：

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）。容量是字符串为了存储更多字符而预先分配的内存量，而长度是当前存储在字符串中的字符数。

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

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()，下面是一个简单的使用示例：

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的扩容机制：

来看看这段代码：

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个字符的空间。

来测试一下：

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:

测试代码：

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:

测试代码：

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:

测试代码：

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 函数用于移除字符串中的所有字符，使其变为空字符串。

下面是个简单的测试：

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 ，即字符串不可修改的。

简单的测试：

int main()
{
	string s1 = "hello world";

	cout << s1[0] << endl;
	cout << s1[2] << endl;
	cout << s1[4] << endl;

	return 0;
}

输出结果为：

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

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函数会执行范围检查，以确保提供的索引没有超出字符串的当前长度。

int main()
{
	string s1("hello world");
	cout << s1.at(0) << endl;
	cout << s1.at(2) << endl;
	return 0;
}

输出结果为：

4.3 front 和 back 函数

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

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+=既可以在末尾添加字符，也可以添加字符串。

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是替换原字符串的某段区间。

示例如下：

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支持删除任意区间。

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 函数用于交换两个字符串对象的内容。

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>> | 流插入重载 |

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

结束语

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

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

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

感谢各位！！！