C++ STL 容器 string 的遍历方法

//迭代器
string::iterator it = s1.begin();
while (it != s1.end()) {
    cout << *it << " ";
    ++it;
}
cout << endl;

string::const_iterator it1 = s2.begin();
while (it1 != s2.end()) {
    cout << *it1 << endl;
    ++it1;
}
cout << endl;

在示例中声明了一个 string::iterator 类型的迭代器 it 和一个 string::const_iterator 类型 it1（区别稍后细说）。在这里可简单将 it 和 it1 看做指针，并将 it 初始化为 s1.begin()，使用循环遍历字符串，直到 it != s1.end()。

s1.begin() 指向字符串的初始位置（第一个字符的位置），s1.end() 指向字符串最后一个位置的下一个位置。

（2）函数原型

（3）位置示意图

（4）string::iterator 和 string::const_iterator 的区别

主要体现在对字符串元素的修改权限上：

• string::iterator：允许通过迭代器修改字符串中的元素。
• string::const_iterator：不允许通过迭代器修改字符串中的元素，只能用于访问。

类比指针可以帮助理解。

3.4 使用范围基于的 for 循环遍历（C++11 及之后版本）

底层实际使用的是迭代器。

//范围 for
for (auto& ch : s1) //自动取 s1 里面的字符自动++
{
    cout << ch << " ";
}

3.5 使用 std::for_each 算法遍历

用 std::for_each 算法遍历 std::string 时，可以传递一个 lambda 表达式或者函数对象作为操作，该函数将对字符串中的每个字符执行操作。std::for_each 算法接受两个迭代器参数，分别指向要遍历的范围的开始和结束（左闭右开），以及一个函数参数，该函数将对范围内的每个元素执行。

（1）函数原型

template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, Function f);

这里，first 和 last 是定义要遍历范围的迭代器，f 是对每个元素执行的函数。

（2）下面是一个使用 std::for_each 算法遍历 std::string 的示例代码：

#include <iostream>
#include <string>
#include <algorithm>

int main() {
    std::string str = "Hello, World!";
    // 使用 std::for_each 遍历字符串
    std::for_each(str.begin(), str.end(), [](char c) {
        std::cout << c << ' ';
    });
    std::cout << std::endl;
    return 0;
}

在这个示例中，std::for_each 接受三个参数：str.begin() 和 str.end() 是 std::string 的迭代器，它们定义了要遍历的范围；第三个参数是一个 lambda 表达式，它接受一个 char 类型的参数并打印它。这个 lambda 表达式将对字符串中的每个字符执行。

（3）补充：

lambda 表达式是一种匿名函数，它允许快速定义单行的小函数，通常用于需要函数对象的地方。

lambda 表达式的语法结构在 C++ 中相对简单明了。它通常遵循以下格式：

[capture](parameters) -> return_type {
    // 函数体
}

然而，并非所有部分都是必需的。在很多常见情况下，lambda 表达式可以被大幅简化。例如，当不需要捕获任何外部变量，且函数体较为简短时，可以省略捕获列表和返回类型，甚至参数列表也可以省略（这种情况下，lambda 表达式将没有参数）。

一个最基本的 lambda 表达式，不接受参数且不执行任何操作，可以是这样： []( ) { };

若需要向 lambda 表达式传递参数，并希望其返回特定类型的值，可以如此定义：

[](int x, int y) -> int {
    return x + y;
};

在 C++11 及之后的版本中，如果 lambda 表达式的函数体仅包含一个 return 语句，且此语句用于返回某个表达式的值，那么可以进一步简化，省略 return 关键字及花括号：

[](int x, int y) -> int { return x + y; }
// 可简化为
[](int x, int y) -> int { x + y }
// 在 C++11 及以后版本中，甚至可以进一步简化为
[](int x, int y) { return x + y; }
// 或
[](int x, int y) { x + y }

最后，如果 lambda 表达式的返回类型可以被编译器明确推断出来，那么返回类型也可以省略： [](int x, int y) { return x + y; }