【C++之泛型算法】009转换和结合元素

transform()

在C++标准库中，std::transform是一个泛型算法，它对给定范围内的每个元素执行一个指定的操作，并将结果存储到另一个容器中。这个算法非常灵活，因为它允许你使用任何满足要求的函数对象或Lambda表达式来定义操作。

下面是一个使用std::transform的简单示例，该示例将std::vector中的每个元素乘以2：

#include <iostream>
#include <vector>
#include <algorithm> // for std::transform
#include <iterator>  // for std::begin, std::end

int main() {
    // 创建一个包含一些整数的向量
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 创建一个新的向量，用于存储转换后的结果
    std::vector<int> doubled_numbers(numbers.size());

    // 使用std::transform将numbers中的每个元素乘以2，并将结果存储到doubled_numbers中
    std::transform(std::begin(numbers), std::end(numbers), std::begin(doubled_numbers),
                   [](int n) { return n * 2; });

    // 输出转换后的结果
    for (const auto& num : doubled_numbers) {
        std::cout << num << " ";
    }

    return 0;
}

在这个例子中，我们使用了Lambda表达式[](int n) { return n * 2; }来定义操作，该操作将每个元素乘以2。std::transform算法遍历numbers向量的每个元素，应用Lambda表达式，并将结果存储到doubled_numbers向量中。

std::transform也可以用于更复杂的操作，比如将字符串中的小写字母转换为大写字母：

#include <iostream>
#include <string>
#include <algorithm> // for std::transform
#include <cctype>    // for std::toupper

int main() {
    // 创建一个包含小写字母的字符串
    std::string lowercase_string = "hello, world!";

    // 使用std::transform将小写字母转换为大写字母
    std::transform(std::begin(lowercase_string), std::end(lowercase_string),
                   std::begin(lowercase_string),
                   [](unsigned char c){ return std::toupper(c); });

    // 输出转换后的结果
    std::cout << lowercase_string << std::endl;

    return 0;
}

在这个例子中，我们使用了std::toupper函数来定义操作，该函数将小写字母转换为大写字母。std::transform算法直接修改lowercase_string中的元素，因为我们提供了相同的开始迭代器作为输入和输出范围。

总之，std::transform是一个强大的泛型算法，它允许你对容器中的元素执行自定义操作，并将结果存储到另一个容器中。
在C++标准库中，std::transform算法有一个带有一个二元操作版本（binary operation version），它接受两个输入范围，并将这两个范围中的元素对应地应用二元操作，然后将结果存储到输出迭代器指向的位置。这个版本的std::transform通常用于将两个序列的元素组合或转换成一个新的序列。

下面是std::transform的带二元操作版本的示例，该示例将两个std::vector中的对应元素相加，并将结果存储到第三个std::vector中：

#include <iostream>
#include <vector>
#include <algorithm> // for std::transform
#include <iterator>  // for std::begin, std::end

int main() {
    // 创建两个包含整数的向量
    std::vector<int> numbers1 = {1, 2, 3, 4, 5};
    std::vector<int> numbers2 = {10, 20, 30, 40, 50};

    // 创建一个新的向量，用于存储转换后的结果
    std::vector<int> sums(numbers1.size());

    // 使用std::transform将两个向量中的对应元素相加，并将结果存储到sums中
    std::transform(std::begin(numbers1), std::end(numbers1),
                   std::begin(numbers2), std::begin(sums),
                   std::plus<int>()); // 使用std::plus作为二元操作

    // 输出转换后的结果
    for (const auto& sum : sums) {
        std::cout << sum << " ";
    }

    return 0;
}

在这个例子中，std::plus()是一个函数对象，它定义了二元操作，即加法。std::transform遍历numbers1和numbers2中的每个对应元素，将它们相加，并将结果存储到sums中。

你也可以使用Lambda表达式作为二元操作，这样可以使代码更加简洁和灵活。下面是一个使用Lambda表达式的相同示例：

#include <iostream>
#include <vector>
#include <algorithm> // for std::transform
#include <iterator>  // for std::begin, std::end

int main() {
    // 创建两个包含整数的向量
    std::vector<int> numbers1 = {1, 2, 3, 4, 5};
    std::vector<int> numbers2 = {10, 20, 30, 40, 50};

    // 创建一个新的向量，用于存储转换后的结果
    std::vector<int> sums(numbers1.size());

    // 使用Lambda表达式作为二元操作
    std::transform(std::begin(numbers1), std::end(numbers1),
                   std::begin(numbers2), std::begin(sums),
                   [](int a, int b) { return a + b; });

    // 输出转换后的结果
    for (const auto& sum : sums) {
        std::cout << sum << " ";
    }

    return 0;
}

在这个使用Lambda表达式的例子中，我们直接定义了二元操作为两个整数的加法。这与使用std::plus()的效果是相同的。Lambda表达式提供了一种更简洁和灵活的方式来定义操作，特别是当操作比较复杂或者需要根据上下文进行定制时。