C++11：std::transform的使用

std::transform在指定的范围内应用于给定的操作，并将结果存储在指定的另一个范围内。要使用std::transform函数需要包含<algorithm>头文件。

以下是std::transform的两个声明，一个是对应于一元操作，一个是对应于二元操作：

template <class InputIterator, class OutputIterator, class UnaryOperation>
  OutputIterator transform (InputIterator first1, InputIterator last1,
                            OutputIterator result, UnaryOperation op);
    
template <class InputIterator1, class InputIterator2,
          class OutputIterator, class BinaryOperation>
  OutputIterator transform (InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, OutputIterator result,
                            BinaryOperation binary_op);

对于一元操作，将op应用于[first1, last1]范围内的每个元素，并将每个操作返回的值存储在以result开头的范围内。给定的op将被连续调用last1-first1+1次。op可以是函数指针或函数对象或lambda表达式。

如op的一个实现 即将[first1, last1]范围内的每个元素加5，然后依次存储到result中。

int op_increase(int i) {return (i + 5)};

调用std::transform的方式如下：

std::transform(first1, last1, result, op_increase);

对于二元操作，使用[first1, last1]范围内的每个元素作为第一个参数调用binary_op,并以first2开头的范围内的每个元素作为第二个参数调用binary_op,每次调用返回的值都存储在以result开头的范围内。给定的binary_op将被连续调用last1-first1+1次。binary_op可以是函数指针或函数对象或lambda表达式。

如binary_op的一个实现即将first1和first2开头的范围内的每个元素相加，然后依次存储到result中。

 int op_add(int, a, int b) {return (a + b)};

调用std::transform的方式如下：

std::transform(first1, last1, first2, result, op_add);

std::transform支持in place，即result和first1指向的位置可以是相同的。std::transform的主要作用应该就是省去了我们自己写for循环实现。

以下是摘自对std::transform的英文解释：

// reference: http://en.cppreference.com/w/cpp/algorithm/transform
template< class InputIt, class OutputIt, class UnaryOperation >
OutputIt transform( InputIt first1, InputIt last1, OutputIt d_first, UnaryOperation unary_op )
{
  while (first1 != last1) {
  *d_first++ = binary_op(*first1++, *first2++);
  }
  return d_first;
}

以下是std::transform用法举例：

#include "transform.hpp"
#include <algorithm> // std::transform
#include <string>
#include <cctype> // std::toupper
#include <iostream>
#include <vector>
#include <functional> // std::plus c++14
 
int test_transform1()
{
    std::string s("Hello");
    std::transform(s.begin(), s.end(), s.begin(),
        [](unsigned char c) { return std::toupper(c); });
    std::cout << s << std::endl; // HELLO
 
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    std::cout << s << std::endl; // hello
 
    
    std::vector<int> arr{ 1, 3, 5 };
    std::vector<int> arr2{ 1, 3, 5 };
    std::vector<int> arr3{ 1, 3, 5 };
 
    std::transform(arr.begin(), arr.end(), arr.begin(),
        [](int d) -> int {return d * 5; }); // for_each
    for (auto value : arr) {
        std::cout << value << "    "; // 5 15 25
    }
    std::cout<<std::endl;
 
    std::for_each(arr2.begin(), arr2.end(), [](int& a) {a *= 5; });
    for (auto value : arr2) {
        std::cout << value << "    "; // 5 15 25
    }
    std::cout << std::endl;
 
    for (auto& value : arr3) {
        value *= 5;
    }
    for (auto value : arr3) {
        std::cout << value << "    "; // 5 15 25
    }
    std::cout << std::endl;
 
    std::vector<std::string> names = { "hi", "test", "foo" };
    std::vector<std::size_t> name_sizes;
 
    ///
    std::transform(names.begin(), names.end(), std::back_inserter(name_sizes),
        [](std::string name) { return name.size(); });
    for (auto value : name_sizes) {
        std::cout << value << "    "; // 2 4 3
    }
    std::cout << std::endl;
 
    std::for_each(name_sizes.begin(), name_sizes.end(), [](std::size_t name_size) {
        std::cout << name_size << "    "; // 2 4 3
    });
    std::cout << std::endl;
 
    return 0;
}
 
/
// reference: http://www.cplusplus.com/reference/algorithm/transform/
static int op_increase(int i) { return ++i; }
 
int test_transform2()
{
    std::vector<int> foo;
    std::vector<int> bar;
 
    // set some values:
    for (int i = 1; i<6; i++)
        foo.push_back(i * 10); // foo: 10 20 30 40 50
 
    bar.resize(foo.size()); // allocate space
 
    std::transform(foo.begin(), foo.end(), bar.begin(), op_increase);
    // bar: 11 21 31 41 51
 
    // std::plus adds together its two arguments:
    std::transform(foo.begin(), foo.end(), bar.begin(), foo.begin(), std::plus<int>());
    // foo: 21 41 61 81 101
 
    std::cout << "foo contains:";
    for (std::vector<int>::iterator it = foo.begin(); it != foo.end(); ++it)
        std::cout << ' ' << *it; // 21 41 61 81 101
    std::cout << '\n';
 
    return 0;
}

GitHub：https://github.com/fengbingchun/Messy_Test
 

#include <iostream>
#include <vector>
#include <numeric>      // std::accumulate

using namespace std;
int main(int argc, const char * argv[]) {
    // 生成若干几个100以内的随机数
    vector<int> numbers(10);
    generate(numbers.begin(), numbers.end(), []{
        return rand()%100;
    });

    // 计算向量里面有多少个奇数
    int odd_count = 0;
    //[]内的odd_count用来捕获外部变量，必须向这样显式指定，否则函数体内无法使用
    //如果[]内不写，编译器会认为不需要捕获任何外部变量
    //在odd_count前面添加&表示按引用传递
    //如果你希望按引用传递捕获当前上下文的所有变量，可以把捕获子句写成[&]；如果你希望按值传递捕获当前上下文的所有变量，可以把捕获子句写成[=]
    //按值传递的变量，无法在lambda内进行赋值
    for_each(numbers.begin(), numbers.end(), [&odd_count](int value){
        if (value%2 == 1) {
            odd_count += 1;
            cout << odd_count<<endl;
        }
    });

    // 生成从0开始的等差为2的等差数列
    int start = -2;
    int step = 2;
    vector<int> numbers2(10);
    generate(numbers2.begin(), numbers2.end(), [start,step] () mutable {
        return start += step;
    });

    for_each(numbers2.begin(), numbers2.end(), [](int value){
        cout<<value<<endl;
    });

    cout<<"-----"<<endl;
    for (auto v:numbers2) cout<<v<<endl;

    // 正确使用transform
    std::transform(numbers2.begin(), numbers2.end(), numbers2.begin(), [](int i){
        return i*i;
    });
    cout<<"---transform--"<<endl;
    for (auto v:numbers2) cout<<v<<endl;

    // 正确使用remove_if
    // remove_if会将符合remove要求的元素放到vector的后面，返回这些元素的首元素的位置
    auto new_end = std::remove_if(numbers2.begin(), numbers2.end(), [](int i){
        return i<100;
    });
    numbers2.erase(new_end, numbers2.end());
    cout<<"---remove_if--"<<endl;
    for (auto v:numbers2) cout<<v<<endl;

    // 正确使用accumulate
    // 第三个参数是初始值，这里取0，表示从0开始累加
    auto sum = accumulate(numbers2.begin(),numbers2.end(),0,[](int a,int b){
        return a+b;
    });
    cout<<"---accumulate--"<<endl;
    cout<<sum<<endl;

    return 0;
}