std::transform C++

最新推荐文章于 2025-03-14 22:43:34 发布

juliosun

最新推荐文章于 2025-03-14 22:43:34 发布

阅读量1k

点赞数

分类专栏： C++/C

C++/C 专栏收录该内容

98 篇文章

订阅专栏

本文详细介绍了C++标准库中的std::transform函数用法，包括一元操作和二元操作两种形式，并通过实例展示了如何使用该函数进行数据转换。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

std::transform

  <algorithm>

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

unary operation(1)

template <class InputIterator, class OutputIterator, class UnaryOperation>
  OutputIterator transform (InputIterator first1, InputIterator last1,
                            OutputIterator result, UnaryOperation op);

binary operation(2)

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

Transform range

Applies an operation sequentially to the elements of one (1) or two (2) ranges and stores the result in the range that begins at result.

(1) unary operation

Applies op to each of the elements in the range [first1,last1) and stores the value returned by each operation in the range that begins at result.

(2) binary operation

Calls binary_op using each of the elements in the range [first1,last1) as first argument, and the respective argument in the range that begins at first2 as second argument. The value returned by each call is stored in the range that begins at result.

The behavior of this function template is equivalent to:

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

The function allows for the destination range to be the same as one of the input ranges to make transformations in place.

Parameters

first1, last1

Input iterators to the initial and final positions of the first sequence. The range used is [first1,last1), which contains all the elements between first1 and last1, including the element pointed by first1 but not the element pointed by last1.

first2

Input iterator to the initial position of the second range. The range includes as many elements as [first1,last1).

result

Output iterator to the initial position of the range where the operation results are stored. The range includes as many elements as [first1,last1).

Unary function that accepts one element of the type pointed by InputIterator as argument, and returns some result value convertible to the type pointed by OutputIterator.
This can either be a function pointer or a function object.

binary_op

Binary function that accepts two elements as argument (one of each of the two sequences), and returns some result value convertible to the type pointed by OutputIterator.
This can either be a function pointer or a function object.

Neither op nor binary_op should directly modify the elements passed as its arguments: These are indirectly modified by the algorithm (using the return value) if the same range is specified for result.

Return value

An iterator pointing to the element that follows the last element written in the result sequence.

Example

// 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;
}

Output:

first contains: 21 41 61 81 101