binary_compose<AdaptableBinaryFunction,AdaptableUnaryFunction1,AdaptableUnaryFunction2>



Categories: functors, adaptors	Component type: type

Description

Binary_compose is a function object adaptor. If f is an Adaptable Binary Function and g1 and g2 are both Adaptable Unary Functions, and if g1's and g2's return types are convertible to f's argument types, then binary_compose can be used to create a function object h such that h(x) is the same as f(g1(x), g2(x)). [1]

Example

Finds the first element in a list that lies in the range from 1 to 10.

list<int> L;
...
list<int>::iterator in_range = 
     find_if(L.begin(), L.end(),
             compose2(logical_and<bool>(),
                      bind2nd(greater_equal<int>(), 1),
                      bind2nd(less_equal<int>(), 10)));
assert(in_range == L.end() || (*in_range >= 1 && *in_range <= 10));

Computes sin(x)/(x + DBL_MIN) for each element of a range.

transform(first, last, first,
          compose2(divides<double>(),
                   ptr_fun(sin),
                   bind2nd(plus<double>(), DBL_MIN)));

Definition

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

Template parameters

Parameter	Description	Default
`AdaptableBinaryFunction`	The type of the "outer" function in the function composition operation. That is, if the `binary_compose` is a function object `h` such that `h(x) = f(g1(x), g2(x))`, then `AdaptableBinaryFunction` is the type of `f`.
`AdaptableUnaryFunction1`	The type of the first "inner" function in the function composition operation. That is, if the `binary_compose` is a function object `h` such that `h(x) = f(g1(x), g2(x))`, then `AdaptableBinaryFunction` is the type of `g1`.
`AdaptableUnaryFunction2`	The type of the second "inner" function in the function composition operation. That is, if the `binary_compose` is a function object `h` such that `h(x) = f(g1(x), g2(x))`, then `AdaptableBinaryFunction` is the type of `g2`.

Model of

Adaptable Unary Function

Type requirements

AdaptableBinaryFunction must be a model of Adaptable Binary Function. AdaptableUnaryFunction1 and AdaptableUnaryFunction2 must both be models of Adaptable Unary Function. The argument types of AdaptableUnaryFunction1 and AdaptableUnaryFunction2 must be convertible to each other. The result types of AdaptableUnaryFunction1 and AdaptableUnaryFunction2 must be convertible, respectively, to the first and second argument types of AdaptableBinaryFunction.

Public base classes

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

Members

Member	Where defined	Description
`argument_type`	Adaptable Unary Function	The type of the function object's argument: `AdaptableUnaryFunction::argument_type`.
`result_type`	Adaptable Unary Function	The type of the result: `AdaptableBinaryFunction::result_type`
binary_compose(const AdaptableBinaryFunction& f, const AdaptableUnaryFunction1& g1, const AdaptableUnaryFunction1& g2);	`binary_compose`	See below.
template <class AdaptableBinaryFunction, class AdaptableUnaryFunction1, class AdaptableUnaryFunction2> binary_compose<AdaptableBinaryFunction, AdaptableUnaryFunction1, AdaptableUnaryFunction2> compose2(const AdaptableBinaryFunction&, const AdaptableUnaryFunction1&, const AdaptableUnaryFunction2&);	`binary_compose`	See below.

New members

These members are not defined in the Adaptable Unary Function requirements, but are specific to binary_compose.

Member	Description
binary_compose(const AdaptableBinaryFunction& f, const AdaptableUnaryFunction1& g1, const AdaptableUnaryFunction1& g2);	The constructor. Constructs a `binary_compose` object such that calling that object with the argument `x` returns `f(g1(x), g2(x))`.
template <class AdaptableBinaryFunction, class AdaptableUnaryFunction1, class AdaptableUnaryFunction2> binary_compose<AdaptableBinaryFunction, AdaptableUnaryFunction1, AdaptableUnaryFunction2> compose2(const AdaptableBinaryFunction&, const AdaptableUnaryFunction1&, const AdaptableUnaryFunction2&);	Creates a `binary_compose` object. If `f`, `g`, and `g2` are, respectively, of classes `AdaptableBinaryFunction`, `AdaptableUnaryFunction1`, and `AdaptableUnaryFunction2`, then `compose2(f, g1, g2)` is equivalent to `binary_compose<AdaptableBinaryFunction, AdaptableUnaryFunction1, AdaptableUnaryFunction2>(f, g1, g2)`, but is more convenient. This is a global function, not a member function.

Notes

[1] This is a form of function composition. The unary_compose adaptor allows composition of Adaptable Unary Functions; note, however, that once binary functions are introduced, there are several possible patterns of function composition. The binary_compose allows you to form a unary function by putting together two unary functions and a binary function, but you could also, for example, imagine putting together two unary functions and a binary function to form a binary function. In that case, f, g1, and g2 would be combined into a function object h such that h(x,y) = f(g1(x), g2(y)).