C++:std::multiplies＜int＞|std::for_each|std::transform

std::multiplies 基本用法

std::multiplies 是一个模板类 std::multiplies 的特化，用于整数类型的乘法。它是一个函数对象，重载了函数调用运算符，使其能够像函数一样使用。

#include <iostream>
#include <functional> // std::multiplies

int main() {
    std::multiplies<int> mult;
    int x = 3;
    int y = 4;
    int result = mult(x, y); // 等价于 result = x * y;

    std::cout << "Result: " << result << '\n'; // 输出 12

    return 0;
}

std::partial_sum 可以接受一个二元运算符作为参数，用于定义如何计算部分和。使用 std::multiplies 可以计算部分乘积。

总结

• std::multiplies 是一个函数对象，用于执行整数类型的乘法运算。
• 它可以与标准算法如 std::partial_sum 结合使用，来定义如何组合元素。
• 使用 std::multiplies 可以简化代码，提高可读性和可维护性。

std::for_each

std::for_each 是 C++ 标准库中的一个算法，用于对给定范围内的每个元素执行指定操作。下面是一个使用
std::for_each 的示例代码，演示如何对一个整数数组中的每个元素执行操作并输出它们。

#include <iostream>
#include <vector>
#include <algorithm> // 包含 std::for_each

// 要对每个元素执行的操作
void printElement(int elem) {
    std::cout << elem << " ";
}

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

    // 使用 std::for_each 对每个元素执行 printElement 函数
    std::for_each(numbers.begin(), numbers.end(), printElement);

    std::cout << std::endl; // 换行

    return 0;
}

也可以使用 lambda 表达式来代替单独定义的函数，以便更简洁地对每个元素执行操作

#include <iostream>
#include <vector>
#include <algorithm> // 包含 std::for_each

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

    // 使用 std::for_each 和 lambda 表达式对每个元素执行操作
    std::for_each(numbers.begin(), numbers.end(), [](int elem) {
        std::cout << elem << " ";
    });

    std::cout << std::endl; // 换行

    return 0;
}

std::transform

std::transform 是 C++ 标准库中的一个算法，用于对一个范围内的每个元素应用一个函数，并将结果存储在另一个范围内。它可以用于单个输入范围或两个输入范围。
下面是一个使用 std::transform 的示例代码，演示如何将一个整数数组中的每个元素加倍并存储在另一个数组中。

#include <iostream>
#include <vector>
#include <algorithm> // 包含 std::transform

// 要应用的函数
int doubleValue(int elem) {
    return elem * 2;
}

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

    // 创建一个用于存储结果的向量
    std::vector<int> result(numbers.size());

    // 使用 std::transform 将每个元素加倍并存储在 result 中
    std::transform(numbers.begin(), numbers.end(), result.begin(), doubleValue);

    // 输出结果向量
    for (int elem : result) {
        std::cout << elem << " ";
    }

    std::cout << std::endl; // 换行

    return 0;
}

定义了一个函数 doubleValue，它将被应用到向量中的每个元素上。std::transform 接受四个参数：起始迭代器、结束迭代器、结果范围的起始迭代器和要应用的函数。可以使用 lambda 表达式来代替单独定义的函数，以便更简洁地对每个元素执行操作

#include <iostream>
#include <vector>
#include <algorithm> // 包含 std::transform

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

    // 创建一个用于存储结果的向量
    std::vector<int> result(numbers.size());

    // 使用 std::transform 和 lambda 表达式将每个元素加倍并存储在 result 中
    std::transform(numbers.begin(), numbers.end(), result.begin(), [](int elem) {
        return elem * 2;
    });

    // 输出结果向量
    for (int elem : result) {
        std::cout << elem << " ";
    }

    std::cout << std::endl; // 换行

    return 0;
}

有两个输入范围，并希望将它们的对应元素进行操作，

#include <iostream>
#include <vector>
#include <algorithm> // 包含 std::transform

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

    // 创建一个用于存储结果的向量
    std::vector<int> result(vec1.size());

    // 使用 std::transform 和 lambda 表达式将每个元素加起来并存储在 result 中
    std::transform(vec1.begin(), vec1.end(), vec2.begin(), result.begin(), [](int a, int b) {
        return a + b;
    });

    // 输出结果向量
    for (int elem : result) {
        std::cout << elem << " ";
    }

    std::cout << std::endl; // 换行

    return 0;
}