functional

This header is part of the function objects library and provides the standard hash function.

Namespaces

Defined in namespace `std::placeholders`
placeholders	Defines placeholders for the unbound arguments in a std::bind expression
Constants
_1, _2, _3, _4, ... (C++11)	placeholders for the unbound arguments in a `std::bind` expression (constant)

Classes

function (C++11)	wraps callable object of any type with specified function call signature (class template)
mem_fn (C++11)	creates a function object out of a pointer to a member (function template)
bad_function_call (C++11)	the exception thrown when invoking an empty `std::function` (class)
is_bind_expression (C++11)	indicates that an object is `std::bind` expression or can be used as one (class template)
is_placeholder (C++11)	indicates that an object is a standard placeholder or can be used as one (class template)
reference_wrapper (C++11)	`CopyConstructible` and `CopyAssignable` reference wrapper (class template)
Hashing
hash (C++11)	hash function object (class template)
template<> struct hash<bool>; template<> struct hash<char>; template<> struct hash<signed char>; template<> struct hash<unsigned char>; template<> struct hash<char16_t>; template<> struct hash<char32_t>; template<> struct hash<wchar_t>; template<> struct hash<short>; template<> struct hash<unsigned short>; template<> struct hash<int>; template<> struct hash<unsigned int>; template<> struct hash<long>; template<> struct hash<long long>; template<> struct hash<unsigned long>; template<> struct hash<unsigned long long>; template<> struct hash<float>; template<> struct hash<double>; template<> struct hash<long double>; template< class T > struct hash<T*>;	`std::hash` specializations for built-in types (class template specialization)

Functions

bind (C++11)	binds one or more arguments to a function object (function template)
refcref (C++11)(C++11)	creates a `std::reference_wrapper` with a type deduced from its argument (function template)

Function Objects

Arithmetic operations
plus	function object implementing `x + y` (class template)
minus	function object implementing `x - y` (class template)
multiplies	function object implementing `x * y` (class template)
divides	function object implementing `x / y` (class template)
modulus	function object implementing `x % y` (class template)
negate	function object implementing `-x` (class template)
Comparisons
equal_to	function object implementing `x == y` (class template)
not_equal_to	function object implementing `x != y` (class template)
greater	function object implementing `x > y` (class template)
less	function object implementing `x < y` (class template)
greater_equal	function object implementing `x >= y` (class template)
less_equal	function object implementing `x <= y` (class template)
Logical operations
logical_and	function object implementing `x && y` (class template)
logical_or	function object implementing `x \|\| y` (class template)
logical_not	function object implementing `!x` (class template)
Bitwise operations
bit_and	function object implementing `x & y` (class template)
bit_or	function object implementing `x \| y` (class template)
bit_xor	function object implementing `x ^ y` (class template)
Negators
unary_negate	wrapper function object returning the complement of the unary predicate it holds (class template)
binary_negate	wrapper function object returning the complement of the binary predicate it holds (class template)
not1	constructs custom `std::unary_negate` object (function template)
not2	constructs custom `std::binary_negate` object (function template)

Deprecated in C++11

Base
unary_function (until C++17)	adaptor-compatible unary function base class (class template)
binary_function (until C++17)	adaptor-compatible binary function base class (class template)
Binders
binder1stbinder2nd (until C++17)(until C++17)	function object holding a binary function and one of its arguments (class template)
bind1stbind2nd (until C++17)(until C++17)	binds one argument to a binary function (function template)
Function adaptors
pointer_to_unary_function (until C++17)	adaptor-compatible wrapper for a pointer to unary function (class template)
pointer_to_binary_function (until C++17)	adaptor-compatible wrapper for a pointer to binary function (class template)
ptr_fun (until C++17)	creates an adaptor-compatible function object wrapper from a pointer to function (function template)
mem_fun_tmem_fun1_tconst_mem_fun_tconst_mem_fun1_t (until C++17)(until C++17)(until C++17)(until C++17)	wrapper for a pointer to nullary or unary member function, callable with a pointer to object (class template)
mem_fun (until C++17)	creates a wrapper from a pointer to member function, callable with a pointer to object (function template)
mem_fun_ref_tmem_fun1_ref_tconst_mem_fun_ref_tconst_mem_fun1_ref_t (until C++17)(until C++17)(until C++17)(until C++17)	wrapper for a pointer to nullary or unary member function, callable with a reference to object (class template)
mem_fun_ref (until C++17)	creates a wrapper from a pointer to member function, callable with a reference to object (function template)

Synopsis

namespace std {
 
    // base (deprecated):
    template <class Arg, class Result> struct unary_function;
    template <class Arg1, class Arg2, class Result> struct binary_function;
 
    // reference_wrapper:
    template <class T> class reference_wrapper;
    template <class T> reference_wrapper<T> ref(T&) noexcept;
    template <class T> reference_wrapper<const T> cref(const T&) noexcept;
    template <class T> void ref(const T&&) = delete;
    template <class T> void cref(const T&&) = delete;
    template <class T> reference_wrapper<T> ref(reference_wrapper<T>) noexcept;
    template <class T> reference_wrapper<const T> cref(reference_wrapper<T>) noexcept;
 
    // arithmetic operations:
    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;
 
    // comparisons:
    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;
 
    // logical operations:
    template <class T> struct logical_and;
    template <class T> struct logical_or;
    template <class T> struct logical_not;
 
    // bitwise operations:
    template <class T> struct bit_and;
    template <class T> struct bit_or;
    template <class T> struct bit_xor;
 
    // negators:
    template <class Predicate> class unary_negate;
    template <class Predicate>
        unary_negate<Predicate> 
        not1(const Predicate&);
    template <class Predicate>  class binary_negate;
    template <class Predicate>
        binary_negate<Predicate>
        not2(const Predicate&);
 
    // bind:
    template<class T> struct is_bind_expression;
    template<class T> struct is_placeholder;
    template<class  F, class... BoundArgs>
        /*unspecified*/ bind(F&&, BoundArgs&&...);
    template<class  R, class F, class... BoundArgs>
        /*unspecified*/ bind(F&&, BoundArgs&&...);
 
    namespace placeholders {
        // M is the implementation-defined number of placeholders
        extern /*unspecified*/ _1;
        extern /*unspecified*/ _2;
        .
        .
        .
        extern /*unspecified*/ _M;
    }
 
    // binders (deprecated):
    template <class Fn> class binder1st;
    template <class Fn, class T>
        binder1st<Fn> bind1st(const Fn&, const T&);
    template <class Fn> class binder2nd;
    template <class Fn, class T>
        binder2nd<Fn> bind2nd(const Fn&, const T&);
 
    // adaptors (deprecated):
    template <class Arg, class Result> class pointer_to_unary_function;
    template <class Arg, class Result>
        pointer_to_unary_function<Arg,Result> ptr_fun(Result (*)(Arg));
    template <class Arg1, class Arg2, class Result>
        class pointer_to_binary_function;
    template <class Arg1, class Arg2, class Result>
        pointer_to_binary_function<Arg1,Arg2,Result>
        ptr_fun(Result (*)(Arg1,Arg2));
 
    // adaptors (deprecated):
    template<class S, class T> class mem_fun_t;
    template<class S, class T, class A> class mem_fun1_t;
    template<class S, class T>
        mem_fun_t<S,T> mem_fun(S (T::*f)());
    template<class S, class T, class A>
        mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));
    template<class S, class T> class mem_fun_ref_t;
    template<class S, class T, class A> class mem_fun1_ref_t;
    template<class S, class T>
        mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)());
    template<class S, class T, class A>
        mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A));
    template <class S, class T> class const_mem_fun_t;
    template <class S, class T, class A> class const_mem_fun1_t;
    template <class S, class T>
        const_mem_fun_t<S,T> mem_fun(S (T::*f)() const);
    template <class S, class T, class A>
        const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const);
    template <class S, class T> class const_mem_fun_ref_t;
    template <class S, class T, class A> class const_mem_fun1_ref_t;
    template <class S, class T>
        const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const);
    template <class S, class T, class A>
        const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);
 
    // member function adaptors:
    template<class R, class T> /*unspecified*/ mem_fn(R T::*);
    template<class R, class T, class... Args>
        /*unspecified*/ mem_fn(R (T::*)(Args...));
    template<class R, class T, class... Args>
        /*unspecified*/ mem_fn(R (T::*)(Args...) const);
    template<class R, class T, class... Args>
        /*unspecified*/ mem_fn(R (T::*)(Args...) volatile);
    template<class R, class T, class... Args>
        /*unspecified*/ mem_fn(R (T::*)(Args...) const volatile);
    template<class R, class T, class... Args>
        /*unspecified*/ mem_fn(R (T::*)(Args...) &);
    template<class R, class T, class... Args>
        /*unspecified*/ mem_fn(R (T::*)(Args...) const &);
    template<class R, class T, class... Args>
        /*unspecified*/ mem_fn(R (T::*)(Args...) volatile &);
    template<class R, class T, class... Args>
        /*unspecified*/ mem_fn(R (T::*)(Args...) const volatile &);
    template<class R, class T, class... Args>
        /*unspecified*/ mem_fn(R (T::*)(Args...) &&);
    template<class R, class T, class... Args>
        /*unspecified*/ mem_fn(R (T::*)(Args...) const &&);
    template<class R, class T, class... Args>
        /*unspecified*/ mem_fn(R (T::*)(Args...) volatile &&);
    template<class R, class T, class... Args>
        /*unspecified*/ mem_fn(R (T::*)(Args...) const volatile &&);
 
    // polymorphic function wrappers:
    class bad_function_call;
    template<class> class function; // undefined
    template<class R, class... ArgTypes> class function<R(ArgTypes...)>;
    template<class R, class... ArgTypes>
        void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
    template<class R, class... ArgTypes>
        bool operator==(const function<R(ArgTypes...)>&, nullptr_t);
    template<class R, class... ArgTypes>
        bool operator==(nullptr_t, const function<R(ArgTypes...)>&);
    template<class R, class... ArgTypes>
        bool operator!=(const function<R(ArgTypes...)>&, nullptr_t);
    template<class R, class... ArgTypes>
        bool operator!=(nullptr_t, const function<R(ArgTypes...)>&);
 
    // hash function base template:
    template <class T> struct hash;
 
    // Hash function specializations
    template <> struct hash<bool>;
    template <> struct hash<char>;
    template <> struct hash<signed char>;
    template <> struct hash<unsigned char>;
    template <> struct hash<char16_t>;
    template <> struct hash<char32_t>;
    template <> struct hash<wchar_t>;
    template <> struct hash<short>;
    template <> struct hash<unsigned short>;
    template <> struct hash<int>;
    template <> struct hash<unsigned int>;
    template <> struct hash<long>;
    template <> struct hash<long long>;
    template <> struct hash<unsigned long>;
    template <> struct hash<unsigned long long>;
    template <> struct hash<float>;
    template <> struct hash<double>;
    template <> struct hash<long double>;
    template<class T> struct hash<T*>;
 
}

Class `std::reference_wrapper`

template <class T> class reference_wrapper {
public :
    // types
    typedef T type;
    typedef /*Return type of T*/     result_type;          // not always defined
    typedef /*Single argument of T*/ argument_type;        // not always defined
    typedef /*1st argument of T*/    first_argument_type;  // not always defined
    typedef /*2nd argument of T*/    second_argument_type; // not always defined
 
    // construct/copy/destroy
    reference_wrapper(T&) noexcept;
    reference_wrapper(T&&) = delete;
 
    // do not bind to temporary objects
    reference_wrapper(const reference_wrapper<T>& x) noexcept;
 
    // assignment
    reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
 
    // access
    operator T& () const noexcept;
    T& get() const noexcept;
 
    // invocation
    template <class... ArgTypes>
        typename result_of<T&(ArgTypes&&...)>::type
        operator() (ArgTypes&&...) const;
 
};

Class `std::is_bind_expression`

template<class T> struct is_bind_expression
    : integral_constant<bool, /*true

Class `std::bad_function_call`

class bad_function_call : public std::exception {
public:
    // constructor:
    bad_function_call() noexcept;
};

Class `std::function`

template<class> class function; // undefined
 
template<class R, class... ArgTypes>
class function<R(ArgTypes...)> {
public:
    typedef R result_type;      
    typedef T1 argument_type;       //  iff sizeof...(ArgTypes) == 1 and
                                    //  the type in ArgTypes is T1
    typedef T1 first_argument_type; //  iff sizeof...(ArgTypes) == 2 and
                                    //  ArgTypes contains T1 and T2
    typedef T2 second_argument_type;//  iff sizeof...(ArgTypes) == 2 and
                                    //  ArgTypes contains T1 and T2
 
    // construct/copy/destroy:
    function() noexcept;
    function(nullptr_t) noexcept;
    function(const function&);
    function(function&&);
 
    template<class F> function(F);
    template<class A> function(allocator_arg_t, const A&) noexcept;
    template<class A> function(allocator_arg_t, const A&, nullptr_t) noexcept;
    template<class A> function(allocator_arg_t, const A&, const function&);
    template<class A> function(allocator_arg_t, const A&, function&&);
    template<class F, class A> function(allocator_arg_t, const A&, F);
 
    function& operator=(const function&);
    function& operator=(function&&);
    function& operator=(nullptr_t);
    template<class F> function& operator=(F&&);
    template<class F> function& operator=(reference_wrapper<F>) noexcept;
 
    ~function();
 
    // function modifiers:
    void swap(function&) noexcept;
    template<class F, class A> void assign(F&&, const A&);
 
    // function capacity:
    explicit operator bool() const noexcept;
 
    // function invocation:
    R operator()(ArgTypes...) const;
 
    // function target access:
    const std::type_info& target_type() const noexcept;
    template <typename T>       T* target() noexcept;
    template <typename T> const T* target() const noexcept;
 
};

`<string>`	Specializes `std::hash` for `std::string`, `std::u16string`, `std::u32string`, `std::wstring`
`<system_error>`	Specializes `std::hash` for `std::error_code`
`<bitset>`	Specializes `std::hash` for `std::bitset`
`<memory>`	Specializes `std::hash` for `std::unique_ptr`, `std::shared_ptr`
`<typeindex>`	Specializes `std::hash` for `std::type_index`
`<vector>`	Specializes `std::hash` for `std::vector<bool>`
`<thread>`	Specializes `std::hash` for `std::thread::id`

functional

Namespaces

Constants

Classes

Hashing

Functions

Function Objects

Arithmetic operations

Comparisons

Logical operations

Bitwise operations

Negators

Deprecated in C++11

Base

Binders

Function adaptors

Synopsis

Class std::reference_wrapper

Class std::is_bind_expression

Class std::bad_function_call

Class std::function

See Also

Class `std::reference_wrapper`

Class `std::is_bind_expression`

Class `std::bad_function_call`

Class `std::function`