

 
Categories: functors, adaptors  Component type: type 
Description
Unary_compose
is a functors adaptor. If f
and g
are both AdaptableUnaryFunction, 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(times<double>(), pi / 180.))));
Definition
Defined in the standard header functional, and in the nonstandard backwardcompatibility 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
AdaptableUnaryFunction
Type requirements
AdaptableUnaryFunction1
and AdaptableUnaryFunction2
must both be models of AdaptableUnaryFunction. 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  AdaptableUnaryFunction  The type of the function object's argument: AdaptableUnaryFunction2::argument_type . 
result_type  AdaptableUnaryFunction  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 AdaptableUnaryFunction 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 functors, binary_compose
, binder1st
, binder2nd
.