STL算法怎么使用 for_each和transform示例

P粉602998670

发布时间：2025-08-16 16:15:02

639人浏览过

来源于php中文网

原创

for_each用于执行副作用操作，如打印或修改元素；transform则用于数据转换，将输入序列映射为新序列，支持一元和二元操作，二者均提升代码清晰度与可维护性。

stl算法怎么使用 for_each和transform示例

STL中的

for_each

和

transform

算法是处理序列数据非常强大的工具，它们提供了一种声明式的方式来对容器中的元素执行操作，避免了手动编写循环的繁琐，并且往往能让代码意图更加清晰。简单来说，

for_each

用于对序列中的每个元素执行一个操作，通常是为了产生副作用，比如打印、修改元素本身；而

transform

则用于将序列中的每个元素通过一个函数映射成新的值，并将这些新值存储到另一个序列中，或者原地更新，它更侧重于数据的转换和生成。

解决方案

在使用STL算法时，我发现很多人，包括我自己，刚开始都会习惯性地写

for

循环。这当然没错，但当你开始接触

for_each

和

transform

，你会发现它们在很多场景下能写出更具表达力、更简洁的代码。

for_each

这个算法的签名大致是

for_each(InputIt first, InputIt last, UnaryFunction f)

。它会遍历

[first, last)

范围内的每一个元素，并对每个元素调用

。这里的

可以是一个函数指针、函数对象（functor）或者Lambda表达式。

我个人最喜欢用

for_each

来做一些“副作用”操作，比如打印容器内容、对元素进行某种状态更新，或者执行一些日志记录。

#include 
#include 
#include  // for_each, transform
#include    // iota

int main() {
    std::vector numbers(5);
    std::iota(numbers.begin(), numbers.end(), 1); // numbers: {1, 2, 3, 4, 5}

    // 使用 for_each 打印每个元素
    std::cout << "打印元素 (for_each): ";
    std::for_each(numbers.begin(), numbers.end(), [](int n) {
        std::cout << n << " ";
    });
    std::cout << std::endl;

    // 使用 for_each 修改元素：将每个元素乘以2 (原地修改，需要非const引用)
    std::cout << "修改元素 (for_each): ";
    std::for_each(numbers.begin(), numbers.end(), [](int& n) {
        n *= 2;
    });
    std::for_each(numbers.begin(), numbers.end(), [](int n) {
        std::cout << n << " ";
    });
    std::cout << std::endl; // numbers: {2, 4, 6, 8, 10}

    // ...

    return 0;
}

transform

transform

则更像是数据管道中的一个“转换器”。它有两种主要形式：

transform(InputIt first, InputIt last, OutputIt d_first, UnaryOperation unary_op)

：对一个输入范围应用一元操作，结果写入一个输出范围。

transform(InputIt1 first1, InputIt1 last1, InputIt2 first2, OutputIt d_first, BinaryOperation binary_op)

：对两个输入范围的对应元素应用二元操作，结果写入一个输出范围。

transform

的强大之处在于它的“映射”能力。当你需要把一种类型的数据转换成另一种类型，或者对数据进行批量计算并生成新结果时，它简直是量身定制。它默认不会修改原始数据，而是将结果写入一个新的目标容器，这符合函数式编程中“不可变性”的思想，我觉得这一点非常棒。

#include 
#include 
#include  // for_each, transform
#include    // iota
#include 

int main() {
    // ... (接上面的代码)

    std::vector original_numbers = {1, 2, 3, 4, 5};

    // 使用 transform 将每个元素平方，存入新vector
    std::vector squared_numbers(original_numbers.size());
    std::transform(original_numbers.begin(), original_numbers.end(), squared_numbers.begin(), [](int n) {
        return n * n;
    });
    std::cout << "平方后的元素 (transform): ";
    std::for_each(squared_numbers.begin(), squared_numbers.end(), [](int n) {
        std::cout << n << " ";
    });
    std::cout << std::endl; // squared_numbers: {1, 4, 9, 16, 25}

    // 使用 transform 将int转换为string
    std::vector string_numbers(original_numbers.size());
    std::transform(original_numbers.begin(), original_numbers.end(), string_numbers.begin(), [](int n) {
        return "Num_" + std::to_string(n);
    });
    std::cout << "转换为字符串 (transform): ";
    std::for_each(string_numbers.begin(), string_numbers.end(), [](const std::string& s) {
        std::cout << s << " ";
    });
    std::cout << std::endl; // string_numbers: {"Num_1", "Num_2", ...}

    // transform 的双输入版本：将两个vector对应元素相加
    std::vector vec1 = {10, 20, 30};
    std::vector vec2 = {1, 2, 3};
    std::vector sum_vec(vec1.size());
    std::transform(vec1.begin(), vec1.end(), vec2.begin(), sum_vec.begin(), [](int a, int b) {
        return a + b;
    });
    std::cout << "两个vector相加 (transform): ";
    std::for_each(sum_vec.begin(), sum_vec.end(), [](int n) {
        std::cout << n << " ";
    });
    std::cout << std::endl; // sum_vec: {11, 22, 33}

    return 0;
}

为什么选择for_each而不是简单的循环？

我经常听到有人说：“不就是个循环嘛，写个

for

有什么难的？”确实，写个

for

循环不难，但问题在于，一个普通的

for

循环把“如何迭代”和“对每个元素做什么”这两件事混在了一起。而

for_each

，或者说整个STL算法库，它的核心思想就是把这两者分离。

对我来说，选择

for_each

有几个很实际的理由：

首先，意图表达更清晰。当你看到

std::for_each(vec.begin(), vec.end(), [](auto& item){ /* ... */ });

，你立刻知道这段代码的目的是“对容器里的每个元素执行一个操作”，而不是“从索引0开始遍历到N-1”。这种高层次的抽象，让代码的阅读者能更快地抓住核心逻辑，而不用去关注迭代器的递增、边界检查这些细节。这在维护大型项目时尤其重要，你不需要在每个循环里都去检查是不是越界了，是不是少了一个元素。

其次，减少样板代码。每次写

for

循环，你都得写

for (auto it = container.begin(); it != container.end(); ++it)

或者

for (size_t i = 0; i < container.size(); ++i)

。虽然现代C++有了范围

for

循环，极大地简化了这部分，但

for_each

仍然在某些特定场景下提供了更强大的灵活性，比如需要传递一个复杂的函数对象，或者在函数式编程风格下进行链式操作。

再者，从某种角度看，使用算法库可以为未来的优化留下空间。虽然

for_each

本身不保证并行执行，但像

std::execution::par

这样的执行策略（C++17引入）可以应用于某些算法，让它们有机会在多核处理器上并行运行。当你习惯了使用这些算法，你的代码就更容易适应未来的并行化需求，而不需要大面积重构。当然，对于简单的

for_each

，这可能有点“过度思考”，但它体现了算法库的宏观设计理念。

当然，我不是说要完全抛弃

for

循环。有时候，一个简单的范围

for

循环，尤其是当操作非常简单，或者需要提前跳出循环时，反而会更直观。关键在于选择最能表达你意图的工具。

transform在数据处理中扮演什么角色？

如果说

for_each

是处理元素的“执行者”，那么

transform

就是处理数据的“炼金术士”。它在数据处理流程中扮演着至关重要的“映射”和“转换”角色。

Closers Copy

营销专用文案机器人

下载

在很多实际项目中，我们经常会遇到这样的场景：从数据库读取了一批原始数据，需要将其格式化、计算或者转换成另一种结构才能用于显示或进一步处理。或者，你可能需要对图像的每个像素进行颜色变换，对音频的每个采样点进行增益调整，或者对金融数据进行批量计算。这些都是

transform

大显身手的地方。

它的核心价值在于：

数据映射与投影：
```
transform
```
能够将一个数据集“投影”到另一个数据集。比如，你有一个
```
std::vector
```
，你可能只想提取每个人的名字，生成一个
```
std::vector
```
。
```
transform
```
可以轻松实现这一点，它就像一个数据过滤器和转换器。
类型转换：将
```
int
```
类型的集合转换为
```
double
```
，或者将数值转换为字符串表示，这些都是
```
transform
```
的拿手好戏。它能优雅地处理这些批量的类型转换需求，避免了手动循环中可能出现的类型转换错误或冗余代码。
批量计算与衍生数据：当你需要对一个集合的所有元素执行相同的数学运算（比如平方、开方、加减乘除）并生成新的结果时，
```
transform
```
是理想的选择。它使得这些批量计算的逻辑变得非常清晰，一眼就能看出你在做什么样的转换。
组合与聚合（双输入版本）：
```
transform
```
的另一个强大之处在于它能处理两个输入序列。这在需要将两个数据集的对应元素进行某种组合操作时非常有用，比如将两个向量对应元素相加，或者根据两个列表的信息生成新的对象。这比手动管理两个迭代器要简洁得多。

我个人在使用

transform

时，常常会把它看作是数据处理管道中的一个环节。比如，我可能会先用

std::remove_if

过滤掉不符合条件的数据，然后用

std::transform

对剩下的数据进行计算或格式化，最后再用

std::for_each

打印或存储结果。这种链式操作让数据流向和处理逻辑变得非常直观。它鼓励我们以一种“函数式”的思维来思考问题：数据经过一系列纯函数的转换，最终得到我们想要的结果。

使用STL算法时常见的“坑”与思考

虽然

for_each

和

transform

这类STL算法非常强大，但用起来也有些小“坑”和需要注意的地方，这都是我踩过坑后总结出来的。

首先，搞混

for_each

和
transform
的用途。这是最常见的，尤其对于初学者。

for_each

设计初衷是执行副作用操作，它返回的是函数对象本身（或者Lambda的闭包类型），而不是一个新的序列。如果你指望它返回一个转换后的新序列，那肯定会失望。而

transform

则明确是为了生成新的序列而生。我见过有人在

for_each

的Lambda里试图

return

一个值，然后期望外部能接收到，这显然是错误的理解。记住：

for_each

是“做事情”，

transform

是“生成新东西”。

其次，迭代器失效问题。虽然

for_each

和

transform

本身不会导致迭代器失效（因为它们不改变容器的结构），但如果你在它们内部的Lambda或者函数对象里，非法地修改了正在遍历的容器（比如

push_back

或

erase

），那就会导致未定义行为。这就像你在修车的时候，突然把车轮拆了，然后还想继续开一样。所以，在使用这些算法时，要特别注意操作的“纯粹性”和对容器的副作用。

transform

因为通常是将结果写入一个新的容器，所以在这方面相对安全。

再者，性能考量。对于非常小的集合，或者操作极其简单（比如仅仅是累加），手动写一个范围

for

循环，其性能可能比

for_each

或

transform

略好一点点，因为它们可能会有额外的函数调用开销。但这通常是微乎其微的，只有在极致优化场景下才需要考虑。更多时候，代码的清晰度和可维护性远比这点微不足道的性能差异重要。不要为了这点小优化而牺牲代码的可读性。

另外，Lambda的捕获机制。在使用Lambda表达式时，捕获变量的方式（值捕获

[var]

、引用捕获

[&var]

、隐式捕获

[=]

或

[&]

）非常关键。如果你在

for_each

中需要修改外部变量，一定要使用引用捕获。例如，我想统计一个向量里有多少个偶数：

std::vector nums = {1, 2, 3, 4, 5, 6};
int even_count = 0;
// 错误：even_count 是值捕获，Lambda内部修改的是副本
// std::for_each(nums.begin(), nums.end(), [even_count](int n) {
//     if (n % 2 == 0) even_count++;
// });
// 正确：even_count 是引用捕获，修改的是外部变量
std::for_each(nums.begin(), nums.end(), [&even_count](int n) {
    if (n % 2 == 0) even_count++;
});
std::cout << "偶数数量: " << even_count << std::endl; // 输出 3

这是一个很常见的错误，也是我当年刚接触Lambda时经常犯的。

最后，过度使用或过度复杂化。STL算法固然好，但并非银弹。如果一个操作逻辑非常复杂，需要多步处理，或者涉及复杂的条件判断和状态管理，强行用