SGI Logo


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 AdaptableUnaryFunction2 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.


STL Main Page

Contact Us | Site Map | Trademarks | Privacy | Using this site means you accept its Terms of Use
Copyright © 2009 - 2016 Silicon Graphics International. All rights reserved.