Whole document tree

www.fifi.org
    Documentation
        Manpages
        GNU Info
        Debian document tree
        Whole document tree
    Trigance web page
    Public services
    User info
    Mailing lists
    Secure server
    Multilingual usage

Whole document tree

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.