<functional>

<functional>

binary_function·binary_negate·binder1st·binder2nd·divides·equal_to·greater ·greater_equal·less·less_equal·logical_and·logical_not·logical_or·mem_fun_t ·mem_fun_ref_t·mem_fun1·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·mem_fun1·mem_fun1_ref·not1·not2 ·ptr_fun

namespace std {
//  TEMPLATE CLASSES
template<class Arg, class Result>
    struct unary_function;
template<class Arg1, class Arg2, class Result>
    struct binary_function;
template<class T>
    struct plus;
template<class T>
    struct minus;
template<class T>
    struct multiplies;
template<class T>
    struct divides;
template<class T>
    struct modulus;
template<class T>
    struct negate;
template<class T>
    struct equal_to;
template<class T>
    struct not_equal_to;
template<class T>
    struct greater;
template<class T>
    struct less;
template<class T>
    struct greater_equal;
template<class T>
    struct less_equal;
template<class T>
    struct logical_and;
template<class T>
    struct logical_or;
template<class T>
    struct logical_not;
template<class Pred>
    struct unary_negate;
template<class Pred>
    struct binary_negate;
template<class Pred>
    class binder1st;
template<class Pred>
    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 R, class T>
    struct mem_fun_t;
template<class R, class T, class A>
    struct mem_fun1_t;
template<class R, class T>
    struct mem_fun_ref_t;
template<class R, class T, class A>
    struct mem_fun1_ref_t;
//  TEMPLATE FUNCTIONS
template<class Pred>
    unary_negate<Pred> not1(const Pred& pr);
template<class Pred>
    binary_negate<Pred> not2(const Pred& pr);
template<class Pred, class T>
    binder1st<Pred> bind1st(const Pred& pr, const T& x);
template<class Pred, class T>
    binder2nd<Pred> bind2nd(const Pred& pr, const T& x);
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 R, class T>
    mem_fun_t<R, T> mem_fun(R (T::*pm)());
template<class R, class T, class A>
    mem_fun1_t<R, T, A> mem_fun1(R (T::*pm)(A arg));
template<class R, class T>
    mem_fun_ref_t<R, T> mem_fun_ref(R (T::*pm)());
template<class R, class T, class A>
    mem_fun1_ref_t<R, T, A> mem_fun1_ref(R (T::*pm)(A arg));
    };

Include the STL standard header <functional> to define several templates that help construct function objects, objects of a class that defines operator(). Hence, function objects behave much like function pointers, except that the object can store additional information that can be used during a function call.