Home Libraries People FAQ More

transform
Prototype

```template<
class SinglePassRange1,
class OutputIterator,
class UnaryOperation
>
OutputIterator transform(const SinglePassRange1& rng,
OutputIterator out,
UnaryOperation fun);

template<
class SinglePassRange1,
class SinglePassRange2,
class OutputIterator,
class BinaryOperation
>
OutputIterator transform(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out,
BinaryOperation fun);
```

Description

UnaryOperation version:

`transform` assigns the value `y` to each element `[out, out + distance(rng)), y = fun(x)` where `x` is the corresponding value to `y` in `rng1`. The return value is ```out + distance(rng)```.

BinaryOperation version:

`transform` assigns the value `z` to each element `[out, out + min(distance(rng1), distance(rng2))), z = fun(x,y)` where `x` is the corresponding value in `rng1` and `y` is the corresponding value in `rng2`. This version of `transform` stops upon reaching either the end of `rng1`, or the end of `rng2`. Hence there isn't a requirement for `distance(rng1) == distance(rng2)` since there is a safe guaranteed behaviour, unlike with the iterator counterpart in the standard library.

The return value is `out + min(distance(rng1), distance(rng2))`.

Definition

Defined in the header file `boost/range/algorithm/transform.hpp`

Requirements

For the unary versions of transform:

• `SinglePassRange1` is a model of the Single Pass Range Concept.
• `OutputIterator` is a model of the `OutputIteratorConcept`.
• `UnaryOperation` is a model of the `UnaryFunctionConcept`.
• `SinglePassRange1`'s value type must be convertible to `UnaryFunction`'s argument type.
• `UnaryFunction`'s result type must be convertible to a type in `OutputIterator`'s set of value types.

For the binary versions of transform:

• `SinglePassRange1` is a model of the Single Pass Range Concept.
• `SinglePassRange2` is a model of the Single Pass Range Concept.
• `OutputIterator` is a model of the `OutputIteratorConcept`.
• `BinaryOperation` is a model of the `BinaryFunctionConcept`.
• `SinglePassRange1`'s value type must be convertible to `BinaryFunction`'s first argument type.
• `SinglePassRange2`'s value type must be convertible to `BinaryFunction`'s second argument type.
• `BinaryOperation`'s result type must be convertible to a type in `OutputIterator`'s set of value types.
Precondition:

For the unary version of transform:

• `out` is not an iterator within the range `[begin(rng1) + 1, end(rng1))`.
• ```[out, out + distance(rng1))``` is a valid range.

For the binary version of transform:

• `out` is not an iterator within the range `[begin(rng1) + 1, end(rng1))`.
• `out` is not an iterator within the range `[begin(rng2) + 1, end(rng2))`.
• ```[out, out + min(distance(rng1), distance(rng2)))``` is a valid range.
Complexity

Linear. The operation is applied exactly `distance(rng1)` for the unary version and `min(distance(rng1), distance(rng2))` for the binary version.