Hosted by

 Categories: functors, adaptors Component type: type

### Description

Unary_compose is a function object adaptor. If f and g are both Adaptable Unary Functions, and if g's return type is convertible to f's argument type, then unary_compose can be used to create a function object h such that h(x) is the same as f(g(x)). [1] As with other function object adaptors, the easiest way to create a unary_compose is to use the helper function compose1. It is possible to call unary_compose's constructor directly, but there is usually no reason to do so.

### Example

Calculates the negative of the sines of the elements in a vector, where the elements are angles measured in degrees. Since the C library function sin takes its arguments in radians, this operation is the composition of three operations: negation, sin, and the conversion of degrees to radians.
```vector<double> angles;
vector<double> sines;
const double pi = 3.14159265358979323846;
...
assert(sines.size() >= angles.size());
transform(angles.begin(), angles.end(), sines.begin(),
compose1(negate<double>(),
compose1(ptr_fun(sin),
bind2nd(multiplies<double>(), pi / 180.))));
```

### Definition

Defined in the standard header functional, and in the nonstandard backward-compatibility header function.h. The unary_compose class is an SGI extension; it is not part of the C++ standard.

### Template parameters

Parameter Description Default
AdaptableUnaryFunction1 The type of the first operand in the function composition operation. That is, if the composition is written f o g [1], then AdaptableUnaryFunction1 is the type of the function object f.
AdaptableUnaryFunction2 The type of the second operand in the function composition operation. That is, if the composition is written f o g [1], then AdaptableUnaryFunction2 is the type of the function object g.

### Public base classes

```unary_function<AdaptableUnaryFunction2::argument_type,
```

### Members

Member Where defined Description
argument_type Adaptable Unary Function The type of the function object's argument: AdaptableUnaryFunction2::argument_type.
```unary_compose(const AdaptableUnaryFunction1& f,
```
unary_compose See below.
```template <class AdaptableUnaryFunction1, class AdaptableUnaryFunction2>
```
unary_compose See below.

### New members

These members are not defined in the Adaptable Unary Function requirements, but are specific to unary_compose.
Member Description
```unary_compose(const AdaptableUnaryFunction1& f,
```
The constructor. Constructs a unary_compose object that represents the function object f o g. [1]
```template <class AdaptableUnaryFunction1, class AdaptableUnaryFunction2>
```
Creates a unary_compose object. If f and g are, respectively, of classes AdaptableUnaryFunction1 and AdaptableUnaryFunction2, then compose1(f, g) is equivalent to unary_compose<AdaptableUnaryFunction1, AdaptableUnaryFunction2>(f, g), but is more convenient. This is a global function, not a member function.

### Notes

[1] This operation is called function composition, hence the name unary_compose. It is often represented in mathematics as the operation f o g, where f o g is a function such that (f o g)(x) == f(g(x)). Function composition is a very important concept in algebra. It is also extremely important as a method of building software components out of other components, because it makes it possible to construct arbitrarily complicated function objects out of simple ones.