<functional>
binary_function
· binary_negate
· binder1st
· binder2nd
· const_mem_fun_t
· const_mem_fun_ref_t
· const_mem_fun1_t
· const_mem_fun1_ref_t
· divides
· equal_to
· greater
· greater_equal
· less
· less_equal
· logical_and
· logical_not
· logical_or
· mem_fun_t
· mem_fun_ref_t
· mem_fun1_t
· mem_fun1_ref_t
· minus
· modulus
· multiplies
· negate
· not_equal_to
· plus
· pointer_to_binary_function
· pointer_to_unary_function
· unary_function
· unary_negate
bind1st
· bind2nd
· mem_fun
· mem_fun_ref
· not1
· not2
· ptr_fun
Include the STL
standard header <functional>
to define several templates that help construct
function objects,
objects of a type that defines operator()
.
A function object can thus be a function pointer, but in
the more general case the object can store additional information
that can be used during a function call.
namespace std { template<class Arg, class Result> struct unary_function; template<class Arg1, class Arg2, class Result> struct binary_function; template<class Ty> struct plus; template<class Ty> struct minus; template<class Ty> struct multiplies; template<class Ty> struct divides; template<class Ty> struct modulus; template<class Ty> struct negate; template<class Ty> struct equal_to; template<class Ty> struct not_equal_to; template<class Ty> struct greater; template<class Ty> struct less; template<class Ty> struct greater_equal; template<class Ty> struct less_equal; template<class Ty> struct logical_and; template<class Ty> struct logical_or; template<class Ty> struct logical_not; template<class Fn1> struct unary_negate; template<class Fn2> struct binary_negate; template<class Fn2> class binder1st; template<class Fn2> class binder2nd; template<class Arg, class Result> class pointer_to_unary_function; template<class Arg1, class Arg2, class Result> class pointer_to_binary_function; template<class Result, class Ty> struct mem_fun_t; template<class Result, class Ty, class Arg> struct mem_fun1_t; template<class Result, class Ty> struct const_mem_fun_t; template<class Result, class Ty, class Arg> struct const_mem_fun1_t; template<class Result, class Ty> struct mem_fun_ref_t; template<class Result, class Ty, class Arg> struct mem_fun1_ref_t; template<class Result, class Ty> struct const_mem_fun_ref_t; template<class Result, class Ty, class Arg> struct const_mem_fun1_ref_t; // TEMPLATE FUNCTIONS template<class Fn1> unary_negate<Fn1> not1(const Fn1& func); template<class Fn2> binary_negate<Fn2> not2(const Fn2& func); template<class Fn2, class Ty> binder1st<Fn2> bind1st(const Fn2& func, const Ty& left); template<class Fn2, class Ty> binder2nd<Fn2> bind2nd(const Fn2& func, const Ty& right); template<class Arg, class Result> pointer_to_unary_function<Arg, Result> ptr_fun(Result (*)(Arg)); template<class Arg1, class Arg2, class Result> pointer_to_binary_function<Arg1, Arg2, Result> ptr_fun(Result (*)(Arg1, Arg2)); template<class Result, class Ty> mem_fun_t<Result, Ty> mem_fun(Result (Ty::*pm)()); template<class Result, class Ty, class Arg> mem_fun1_t<Result, Ty, Arg> mem_fun(Result (Ty::*pm)(Arg left)); template<class Result, class Ty> const_mem_fun_t<Result, Ty> mem_fun(Result (Ty::*pm)() const); template<class Result, class Ty, class Arg> const_mem_fun1_t<Result, Ty, Arg> mem_fun(Result (Ty::*pm)(Arg left) const); template<class Result, class Ty> mem_fun_ref_t<Result, Ty> mem_fun_ref(Result (Ty::*pm)()); template<class Result, class Ty, class Arg> mem_fun1_ref_t<Result, Ty, Arg> mem_fun_ref(Result (Ty::*pm)(Arg left)); template<class Result, class Ty> const_mem_fun_ref_t<Result, Ty> mem_fun_ref(Result (Ty::*pm)() const); template<class Result, class Ty, class Arg> const_mem_fun1_ref_t<Result, Ty, Arg> mem_fun_ref(Result (Ty::*pm)(Arg left) const); };
binary_function
template<class Arg1, class Arg2, class Result> struct binary_function { typedef Arg1 first_argument_type; typedef Arg2 second_argument_type; typedef Result result_type; };
The template class serves as a base for classes that define a member function of the form:
result_type operator()(const first_argument_type&, const second_argument_type&) const
or a similar form taking two arguments.
Hence, all such
binary functions
can refer to their first argument type as
first_argument_type
,
their second argument type as
second_argument_type
,
and their return type as
result_type
.
binary_negate
template<class Fn2> class binary_negate : public binary_function< typename Fn2::first_argument_type, typename Fn2::second_argument_type, bool> { public: explicit binary_negate(const Fn2& func); bool operator()( const typename Fn2::first_argument_type& left, const typename Fn2::second_argument_type& right) const; };
The template class stores a copy of func
, which
must be a binary function object.
It defines its member function operator()
as returning !func(left, right)
.
bind1st
template<class Fn2, class Ty> binder1st<Fn2> bind1st(const Fn2amp; func, const Ty& left);
The function returns
binder1st<Fn2>(func,
typename Fn2::first_argument_type(left))
.
bind2nd
template<class Fn2, class Ty> binder2nd<Fn2> bind2nd(const Fn2& func, const Ty& right);
The function returns
binder2nd<Fn2>(func,
typename Fn2::second_argument_type(right))
.
binder1st
template<class Fn2> class binder1st : public unary_function< typename Fn2::second_argument_type, typename Fn2::result_type> { public: typedef typename Fn2::second_argument_type argument_type; typedef typename Fn2::result_type result_type; binder1st(const Fn2& func, const typename Fn2::first_argument_type& left); result_type operator()(const argument_type& right) const; protected: Fn2 op; typename Fn2::first_argument_type value; };
The template class stores a copy of func
, which
must be a binary function object, in
op
,
and a copy of left
in
value
.
It defines its member function operator()
as returning op(value, right)
.
binder2nd
template<class Fn2> class binder2nd : public unary_function< typename Fn2::first_argument_type, typename Fn2::result_type> { public: typedef typename Fn2::first_argument_type argument_type; typedef typename Fn2::result_type result_type; binder2nd(const Fn2& func, const typename Fn2::second_argument_type& right); result_type operator()(const argument_type& left) const; protected: Fn2 op; typename Fn2::second_argument_type value; };
The template class stores a copy of func
, which
must be a binary function object, in
op
,
and a copy of right
in
value
.
It defines its member function operator()
as returning op(left, value)
.
const_mem_fun_t
template<class Result, class Ty> struct const_mem_fun_t : public unary_function<const Ty *, Result> { explicit const_mem_fun_t(Result (Ty::*pm)() const); Result operator()(const Ty *pleft) const; };
The template class stores a copy of pm
, which
must be a pointer to a member function of class Ty
, in
a private member object.
It defines its member function operator()
as returning (pleft->*pm)() const
.
const_mem_fun_ref_t
template<class Result, class Ty> struct const_mem_fun_ref_t : public unary_function<Ty, Result> { explicit const_mem_fun_t(Result (Ty::*pm)() const); Result operator()(const Ty& left) const; };
The template class stores a copy of pm
, which
must be a pointer to a member function of class Ty
, in
a private member object.
It defines its member function operator()
as returning (left.*pm)() const
.
const_mem_fun1_t
template<class Result, class Ty, class Arg> struct const_mem_fun1_t : public binary_function<const Ty *, Arg, Result> { explicit const_mem_fun1_t(Result (Ty::*pm)(Arg) const); Result operator()(const Ty *pleft, Arg right) const; };
The template class stores a copy of pm
, which
must be a pointer to a member function of class Ty
, in
a private member object.
It defines its member function operator()
as returning (pleft->*pm)(right) const
.
const_mem_fun1_ref_t
template<class Result, class Ty, class Arg> struct const_mem_fun1_ref_t : public binary_function<Ty, Arg, Result> { explicit const_mem_fun1_ref_t(Result (Ty::*pm)(Arg) const); Result operator()(const Ty& left, Arg right) const; };
The template class stores a copy of pm
, which
must be a pointer to a member function of class Ty
, in
a private member object.
It defines its member function operator()
as returning (left.*pm)(right) const
.
divides
template<class Ty> struct divides : public binary_function<Ty, Ty, Ty> { Ty operator()(const Ty& left, const Ty& right) const; };
The template class defines its member function as returning
left / right
.
equal_to
template<class Ty> struct equal_to : public binary_function<Ty, Ty, bool> { bool operator()(const Ty& left, const Ty& right) const; };
The template class defines its member function as returning
left == right
.
greater
template<class Ty> struct greater : public binary_function<Ty, Ty, bool> { bool operator()(const Ty& left, const Ty& right) const; };
The template class defines its member function as returning
left > right
. The member function defines a
total ordering
if Ty
is an object pointer type. (It will compare two pointer values
consistently even if they don't point into the same array.)
greater_equal
template<class Ty> struct greater_equal : public binary_function<Ty, Ty, bool> { bool operator()(const Ty& left, const Ty& right) const; };
The template class defines its member function as returning
left >= right
. The member function defines a
total ordering
if Ty
is an object pointer type. (It will compare two pointer values
consistently even if they don't point into the same array.)
less
template<class Ty> struct less : public binary_function<Ty, Ty, bool> { bool operator()(const Ty& left, const Ty& right) const; };
The template class defines its member function as returning
left < right
. The member function defines a
total ordering
if Ty
is an object pointer type. (It will compare two pointer values
consistently even if they don't point into the same array.)
less_equal
template<class Ty> struct less_equal : public binary_function<Ty, Ty, bool> { bool operator()(const Ty& left, const Ty& right) const; };
The template class defines its member function as returning
left <= right
. The member function defines a
total ordering
if Ty
is an object pointer type. (It will compare two pointer values
consistently even if they don't point into the same array.)
logical_and
template<class Ty> struct logical_and : public binary_function<Ty, Ty, bool> { bool operator()(const Ty& left, const Ty& right) const; };
The template class defines its member function as returning
left && right
.
logical_not
template<class Ty> struct logical_not : public unary_function<Ty, bool> { bool operator()(const Ty& left) const; };
The template class defines its member function as returning
!left
.
logical_or
template<class Ty> struct logical_or : public binary_function<Ty, Ty, bool> { bool operator()(const Ty& left, const Ty& right) const; };
The template class defines its member function as returning
left || right
.
mem_fun
template<class Result, class Ty> mem_fun_t<Result, Ty> mem_fun(Result (Ty::*pm)()); template<class Result, class Ty, class Arg> mem_fun1_t<Result, Ty, Arg> mem_fun(Result (Ty::*pm)(Arg)); template<class Result, class Ty> const_mem_fun_t<Result, Ty> mem_fun(Result (Ty::*pm)() const); template<class Result, class Ty, class Arg> const_mem_fun1_t<Result, Ty, Arg> mem_fun(Result (Ty::*pm)(Arg) const);
The template function returns pm
cast to the return type.
mem_fun_ref
template<class Result, class Ty> mem_fun_ref_t<Result, Ty> mem_fun_ref(Result (Ty::*pm)()); template<class Result, class Ty, class Arg> mem_fun1_ref_t<Result, Ty, Arg> mem_fun_ref(Result (Ty::*pm)(Arg)); template<class Result, class Ty> const_mem_fun_ref_t<Result, Ty> mem_fun_ref(Result (Ty::*pm)() const); template<class Result, class Ty, class Arg> const_mem_fun1_ref_t<Result, Ty, Arg> mem_fun_ref(Result (Ty::*pm)(Arg) const);
The template function returns pm
cast to the return type.
mem_fun_t
template<class Result, class Ty> struct mem_fun_t : public unary_function<Ty *, Result> { explicit mem_fun_t(Result (Ty::*pm)()); Result operator()(Ty *pleft) const; };
The template class stores a copy of pm
, which
must be a pointer to a member function of class Ty
, in
a private member object.
It defines its member function operator()
as returning (pleft->*pm)()
.
mem_fun_ref_t
template<class Result, class Ty> struct mem_fun_ref_t : public unary_function<Ty, Result> { explicit mem_fun_t(Result (Ty::*pm)()); Result operator()(Ty& left) const; };
The template class stores a copy of pm
, which
must be a pointer to a member function of class Ty
, in
a private member object.
It defines its member function operator()
as returning (left.*pm)()
.
mem_fun1_t
template<class Result, class Ty, class Arg> struct mem_fun1_t : public binary_function<Ty *, Arg, Result> { explicit mem_fun1_t(Result (Ty::*pm)(Arg)); Result operator()(Ty *pleft, Arg right) const; };
The template class stores a copy of pm
, which
must be a pointer to a member function of class Ty
, in
a private member object.
It defines its member function operator()
as returning (pleft->*pm)(right)
.
mem_fun1_ref_t
template<class Result, class Ty, class Arg> struct mem_fun1_ref_t : public binary_function<Ty, Arg, Result> { explicit mem_fun1_ref_t(Result (Ty::*pm)(Arg)); Result operator()(Ty& left, Arg right) const; };
The template class stores a copy of pm
, which
must be a pointer to a member function of class Ty
, in
a private member object.
It defines its member function operator()
as returning (left.*pm)(right)
.
minus
template<class Ty> struct minus : public binary_function<Ty, Ty, Ty> { Ty operator()(const Ty& left, const Ty& right) const; };
The template class defines its member function as returning
left - right
.
modulus
template<class Ty> struct modulus : public binary_function<Ty, Ty, Ty> { Ty operator()(const Ty& left, const Ty& right) const; };
The template class defines its member function as returning
left % right
.
multiplies
template<class Ty> struct multiplies : public binary_function<Ty, Ty, Ty> { Ty operator()(const Ty& left, const Ty& right) const; };
The template class defines its member function as returning
left * right
.
negate
template<class Ty> struct negate : public unary_function<Ty, Ty> { Ty operator()(const Ty& left) const; };
The template class defines its member function as returning
-left
.
not1
template<class Fn1> unary_negate<Fn1> not1(const Fn1& func);
The template function returns
unary_negate<Fn1>(func)
.
not2
template<class Fn2> binary_negate<Fn2> not2(const Fn2& func);
The template function returns
binary_negate<Fn2>(func)
.
not_equal_to
template<class Ty> struct not_equal_to : public binary_function<Ty, Ty, bool> { bool operator()(const Ty& left, const Ty& right) const; };
The template class defines its member function as returning
left != right
.
plus
template<class Ty> struct plus : public binary_function<Ty, Ty, Ty> { Ty operator()(const Ty& left, const Ty& right) const; };
The template class defines its member function as returning
left + right
.
pointer_to_binary_function
template<class Arg1, class Arg2, class Result> class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result> { public: explicit pointer_to_binary_function( Result (*pfunc)(Arg1, Arg2)); Result operator()(const Arg1 left, const Arg2 right) const; };
The template class stores a copy of pfunc
.
It defines its member function operator()
as returning (*pfunc)(left, right)
.
pointer_to_unary_function
template<class Arg, class Result> class pointer_to_unary_function : public unary_function<Arg, Result> { public: explicit pointer_to_unary_function( Result (*pfunc)(Arg)); Result operator()(const Arg left) const; };
The template class stores a copy of pfunc
.
It defines its member function operator()
as returning (*pfunc)(left)
.
ptr_fun
template<class Arg, class Result> pointer_to_unary_function<Arg, Result> ptr_fun(Result (*pfunc)(Arg)); template<class Arg1, class Arg2, class Result> pointer_to_binary_function<Arg1, Arg2, Result> ptr_fun(Result (*pfunc)(Arg1, Arg2));
The first template function returns
pointer_to_unary_function<Arg, Result>(pfunc)
.
The second template function returns
pointer_to_binary_function<Arg1, Arg2, Result>(pfunc)
.
unary_function
template<class Arg, class Result> struct unary_function { typedef Arg argument_type; typedef Result result_type; };
The template class serves as a base for classes that define a member function of the form:
result_type operator()(const argument_type&) const
or a similar form taking one argument.
Hence, all such
unary functions
can refer to their sole argument type as
argument_type
and their return type as
result_type
.
unary_negate
template<class Fn1> class unary_negate : public unary_function< typename Fn1::argument_type, bool> { public: explicit unary_negate(const Fn1& Func); bool operator()( const typename Fn1::argument_type& left) const; };
The template class stores a copy of func
, which
must be a unary function object.
It defines its member function operator()
as returning !func(left)
.
See also the Table of Contents and the Index.
Copyright © 1994-2002 by P.J. Plauger. Portions derived from work copyright © 1994 by Hewlett-Packard Company. All rights reserved.