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);

(1) unary operation

将op应用于[first1,last1]范围内的每个元素， 并将每个操作返回的值存储在从result开始的范围内。

(2) binary operation

使用范围[first1,last1]中的每个元素作为第一个参数调用binary_op， 并将从first2开始的范围中的各个参数作为第二个参数。 每次调用返回的值存储在result处开始的范围内。

template <class InputIterator, class OutputIterator, class UnaryOperator>
  OutputIterator transform (InputIterator first1, InputIterator last1,
                            OutputIterator result, UnaryOperator op)
{
  while (first1 != last1) {
    *result = op(*first1);  // or: *result=binary_op(*first1,*first2++);
    ++result; ++first1;
  }
  return result;
}

☲  参数

first1, last1

指向一个序列初始和最终位置的输入迭代器。使用的范围是[first1,last1)， 它包含first1和last1之间的所有元素，包括first1指向的元素，但不包括last1指向的元素。

first2

指向第二个范围的初始位置的输入迭代器。该范围包含与[first1,last1)一样多的元素。

result

指向存储操作结果范围的初始位置的输出迭代器。该范围包含与[first1,last1)一样多的元素。

op

一个一元函数，它接受输入迭代器(InputIterator)指向的类型的一个元素作为参数， 并返回一些可转换为输出迭代器(OutputIterator)指向的类型的结果值。
它可以是函数指针，也可以是函数对象。

binary_op

接受两个元素作为参数(两个序列各一个)的二进制函数， 并返回一些可转换为输出迭代器(OutputIterator)指向的类型的结果值。
它可以是函数指针，也可以是函数对象。

☉  返回值

☣  示例

// transform algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::transform
#include <vector>       // std::vector
#include <functional>   // std::plus

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

int main () {
  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;
  std::cout << '\n';

  return 0;
}

✥ 复杂度

⇄ 数据竞争

☂ 异常安全性

🍄  另请参阅