|
transform
function template
<algorithm>
template < class InputIterator, class OutputIterator, class UnaryOperator >
OutputIterator transform ( InputIterator first1, InputIterator last1,
OutputIterator result, UnaryOperator op );
template < class InputIterator1, class InputIterator2,
class OutputIterator, class BinaryOperator >
OutputIterator transform ( InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, OutputIterator result,
BinaryOperator binary_op );
Apply function to range
The first version applies op to all the elements in the input range ([first1,last1)) and stores each returned value in the range beginning at result.
The second version uses as argument for each call to binary_op one element from the first input range ([first1,last1)) and one element from the second input range (beginning at first2).
The behavior of this function template is equivalent to:
1
2
3
4
5
6
7
8
|
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++);
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 function results are stored. The rangeincludes as many elements as [first1,last1).
- op
- Unary function taking one element as argument, and returning some result value. This can either be a pointer to a function or an object whose class overloads operator().
- binary_op
- Binary function taking two elements as argument (one of each of the two sequences), and returning some result value. This can either be a pointer to a function or an object whose class overloads operator().
Return value
An iterator pointing to the element that follows the last element written in the result sequence.
Example
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
// transform algorithm example
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int op_increase (int i) { return ++i; }
int op_sum (int i, int j) { return i+j; }
int main () {
vector<int> first;
vector<int> second;
vector<int>::iterator it;
// set some values:
for (int i=1; i<6; i++) first.push_back (i*10); // first: 10 20 30 40 50
second.resize(first.size()); // allocate space
transform (first.begin(), first.end(), second.begin(), op_increase);
// second: 11 21 31 41 51
transform (first.begin(), first.end(), second.begin(), first.begin(), op_sum);
// first: 21 41 61 81 101
cout << "first contains:";
for (it=first.begin(); it!=first.end(); ++it)
cout << " " << *it;
cout << endl;
return 0;
}
|
Output:
first contains: 21 41 61 81 101
|
Complexity
Linear: Performs as many assignments and applications of op or binary_op as the number of elements in the range [first1,last1).
See also
| for_each | Apply function to range (template function) |
| copy | Copy range of elements (function template) |
|