# <functional>

<head><title>&lt;functional&gt;</title></head>

# `<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](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_index.html#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);
    }  // namespace stdCopy to clipboard

## `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;
        };Copy to clipboard

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&) constCopy to clipboard

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;
        };Copy to clipboard

The template class stores a copy of `func`, which
must be a [binary function](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_functio2.html#binary%20functions) object.
It defines its member function **`operator()`**
as returning `!func(left, right)`.

##  `bind1st`

    template<class Fn2, class Ty>
        binder1st<Fn2> bind1st(const Fn2& func, const Ty& left);Copy to clipboard

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);Copy to clipboard

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;
        };Copy to clipboard

The template class stores a copy of `func`, which
must be a [binary function](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_functio2.html#binary%20functions) 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;
        };Copy to clipboard

The template class stores a copy of `func`, which
must be a [binary function](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_functio2.html#binary%20functions) 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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

The template class defines its member function as returning
`left > right`. The member function defines a
[total ordering](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_utility.html#total%20ordering)
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;
        };Copy to clipboard

The template class defines its member function as returning
`left >= right`. The member function defines a
[total ordering](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_utility.html#total%20ordering)
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;
        };Copy to clipboard

The template class defines its member function as returning
`left < right`. The member function defines a
[total ordering](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_utility.html#total%20ordering)
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;
        };Copy to clipboard

The template class defines its member function as returning
`left <= right`. The member function defines a
[total ordering](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_utility.html#total%20ordering)
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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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);Copy to clipboard

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);Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

The template class defines its member function as returning
`-left`.

## `not1`

    template<class Fn1>
        unary_negate<Fn1> not1(const Fn1& func);Copy to clipboard

The template function returns
`unary_negate<Fn1>(func)`.

## `not2`

    template<class Fn2>
        binary_negate<Fn2> not2(const Fn2& func);Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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;
        };Copy to clipboard

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));Copy to clipboard

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;
        };Copy to clipboard

The template class serves as a base for classes that define
a member function of the form:

    result_type operator()(const argument_type&) constCopy to clipboard

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;
        };Copy to clipboard

The template class stores a copy of `func`, which
must be a [unary function](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_functio2.html#unary%20functions) object.
It defines its member function **`operator()`**
as returning `!func(left)`.

* * *

See also the
**[Table of Contents](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_index.html#Table%20of%20Contents)** and the
**[Index](https://docs.qualcomm.com/doc/80-N3040-23/topic/_cpp_index.html)**.

*[Copyright](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_crit_pjp.html) © 1992-2006by P.J. Plauger. Portions derived from work[copyright](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_crit_hp.html) © 1994by Hewlett-Packard Company. All rights reserved.*

<!--V5.01:1566-->

Last Published: Oct 06, 2026

Previous Topic
 
<fstream.h></fstream.h> Next Topic

<hash_map></hash_map>