# unary_compose<AdaptableUnaryFunction1,AdaptableUnaryFunction2>

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 `AdaptableUnaryFunction1` is the type of the function object `g`. |

### Model of

Adaptable Unary Function

### Type requirements

`AdaptableUnaryFunction1` and `AdaptableUnaryFunction2` must both be models of Adaptable Unary Function. `AdaptableUnaryFunction2::result_type` must be convertible to `AdaptableUnaryFunction1::argument_type`.

### Public base classes

    unary_function<AdaptableUnaryFunction2::argument_type,
                   AdaptableUnaryFunction1::result_type>

### Members

Member | Where defined | Description
--- | --- | ---
`argument_type` | Adaptable Unary Function | The type of the function object's argument: `AdaptableUnaryFunction2::argument_type`.
`result_type` | Adaptable Unary Function | The type of the result: `AdaptableUnaryFunction1::result_type`
    unary_compose(const AdaptableUnaryFunction1& f,
                  const AdaptableUnaryFunction2& g);
| `unary_compose` | See below.
    template <class AdaptableUnaryFunction1, class AdaptableUnaryFunction2>
    unary_compose<AdaptableUnaryFunction1, AdaptableUnaryFunction2>
    compose1(const AdaptableUnaryFunction1& op1,
             const AdaptableUnaryFunction2& op2);
| `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,
                  const AdaptableUnaryFunction2& g);
| The constructor. Constructs a `unary_compose` object that represents the function object `f o g`. [1]
    template <class AdaptableUnaryFunction1, class AdaptableUnaryFunction2>
    unary_compose<AdaptableUnaryFunction1, AdaptableUnaryFunction2>
    compose1(const AdaptableUnaryFunction1& op1,
             const AdaptableUnaryFunction2& op2);
| 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.

### See also

The function object overview, `binary_compose`, `binder1st`, `binder2nd`.

Copyright © 1999 Silicon Graphics, Inc. All Rights Reserved. TrademarkInformation