##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Standard library header <functional>

From cppreference.com
< cpp‎ | header

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

### [edit] Namespaces

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

### [edit] Classes

function (C++11) | wraps callable object of any type with specified function call signature (class template) [edit]
mem_fn (C++11) | creates a function object out of a pointer to a member (function template) [edit]
bad_function_call (C++11) | the exception thrown when invoking an empty std::function (class) [edit]
is_bind_expression (C++11) | indicates that an object is `std::bind` expression or can be used as one (class template) [edit]
is_placeholder (C++11) | indicates that an object is a standard placeholder or can be used as one (class template) [edit]
reference_wrapper (C++11) | `CopyConstructible` and `CopyAssignable` reference wrapper (class template) [edit]
##### Hashing
hash (C++11) | hash function object (class template) [edit]
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)

### [edit] Functions

bind (C++11) | binds one or more arguments to a function object (function template) [edit]
ref cref (C++11)(C++11) | creates a std::reference_wrapper with a type deduced from its argument (function template) [edit]
invoke (C++17) | invokes any `Callable` object with given arguments (function template) [edit]

### [edit] Function Objects

##### Arithmetic operations
plus | function object implementing x + y (class template) [edit]
minus | function object implementing x - y (class template) [edit]
multiplies | function object implementing x * y (class template) [edit]
divides | function object implementing x / y (class template) [edit]
modulus | function object implementing x % y (class template) [edit]
negate | function object implementing -x (class template) [edit]
##### Comparisons
equal_to | function object implementing x == y (class template) [edit]
not_equal_to | function object implementing x != y (class template) [edit]
greater | function object implementing x > y (class template) [edit]
less | function object implementing x < y (class template) [edit]
greater_equal | function object implementing x >= y (class template) [edit]
less_equal | function object implementing x <= y (class template) [edit]
##### Logical operations
logical_and | function object implementing x && y (class template) [edit]
logical_or | function object implementing x || y (class template) [edit]
logical_not | function object implementing !x (class template) [edit]
##### Bitwise operations
bit_and | function object implementing x & y (class template) [edit]
bit_or | function object implementing x | y (class template) [edit]
bit_xor | function object implementing x ^ y (class template) [edit]
bit_not (C++14) | function object implementing ~x (class template) [edit]
##### Negators
not_fn (C++17) | Creates a function object that returns the complement of the result of the function object it holds (function template) [edit]
unary_negate (deprecated) | wrapper function object returning the complement of the unary predicate it holds (class template) [edit]
binary_negate (deprecated) | wrapper function object returning the complement of the binary predicate it holds (class template) [edit]
not1 (deprecated) | constructs custom std::unary_negate object (function template) [edit]
not2 (deprecated) | constructs custom std::binary_negate object (function template) [edit]
##### Searchers
default_searcher (C++17) | standard C++ library search algorithm implementation (class template) [edit]
boyer_moore_searcher (C++17) | Boyer-Moore search algorithm implementation (class template) [edit]
boyer_moore_horspool_searcher (C++17) | Boyer-Moore-Horspool search algorithm implementation (class template) [edit]

### [edit] Deprecated in C++11 and removed in C++17

##### Base
unary_function (until C++17) | adaptor-compatible unary function base class (class template) [edit]
binary_function (until C++17) | adaptor-compatible binary function base class (class template) [edit]
##### Binders
binder1st binder2nd (until C++17)(until C++17) | function object holding a binary function and one of its arguments (class template) [edit]
bind1st bind2nd (until C++17)(until C++17) | binds one argument to a binary function (function template) [edit]
##### Function adaptors
pointer_to_unary_function (until C++17) | adaptor-compatible wrapper for a pointer to unary function (class template) [edit]
pointer_to_binary_function (until C++17) | adaptor-compatible wrapper for a pointer to binary function (class template) [edit]
ptr_fun (until C++17) | creates an adaptor-compatible function object wrapper from a pointer to function (function template) [edit]
mem_fun_t mem_fun1_t const_mem_fun_t const_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) [edit]
mem_fun (until C++17) | creates a wrapper from a pointer to member function, callable with a pointer to object (function template) [edit]
mem_fun_ref_t mem_fun1_ref_t const_mem_fun_ref_t const_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) [edit]
mem_fun_ref (until C++17) | creates a wrapper from a pointer to member function, callable with a reference to object (function template) [edit]

### [edit] Synopsis

    namespace std {
      // invoke:
      template <class F, class... Args>
      invoke_result_t<F, Args...> invoke(F&& f, Args&&... args);

      // 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 = void> struct plus;
      template <class T = void> struct minus;
      template <class T = void> struct multiplies;
      template <class T = void> struct divides;
      template <class T = void> struct modulus;
      template <class T = void> struct negate;
      template <> struct plus<void>;
      template <> struct minus<void>;
      template <> struct multiplies<void>;
      template <> struct divides<void>;
      template <> struct modulus<void>;
      template <> struct negate<void>;

      // comparisons:
      template <class T = void> struct equal_to;
      template <class T = void> struct not_equal_to;
      template <class T = void> struct greater;
      template <class T = void> struct less;
      template <class T = void> struct greater_equal;
      template <class T = void> struct less_equal;
      template <> struct equal_to<void>;
      template <> struct not_equal_to<void>;
      template <> struct greater<void>;
      template <> struct less<void>;
      template <> struct greater_equal<void>;
      template <> struct less_equal<void>;

      // logical operations:
      template <class T = void> struct logical_and;
      template <class T = void> struct logical_or;
      template <class T = void> struct logical_not;
      template <> struct logical_and<void>;
      template <> struct logical_or<void>;
      template <> struct logical_not<void>;

      // bitwise operations:
      template <class T = void> struct bit_and;
      template <class T = void> struct bit_or;
      template <class T = void> struct bit_xor;
      template <class T = void> struct bit_not;
      template <> struct bit_and<void>;
      template <> struct bit_or<void>;
      template <> struct bit_xor<void>;
      template <> struct bit_not<void>;

      // function template not_fn:
      template <class F> /*unspecified*/ not_fn(F&& f);

      // 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
        /* implementation-defined */ _1;
        /* implementation-defined */ _2;
        ...
        /* implementation-defined */ _M;
      }

      // member function adaptors:
      template<class R, class T> /*unspecified*/ mem_fn(R T::*) noexcept;

      // 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) noexcept;
      template<class R, class... ArgTypes>
      bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
      template<class R, class... ArgTypes>
      bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
      template<class R, class... ArgTypes>
      bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;

      // searchers:
      template<class ForwardIterator, class BinaryPredicate = equal_to<>>
      class default_searcher;
      template<class RandomAccessIterator,
               class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
               class BinaryPredicate = equal_to<>>
      class boyer_moore_searcher;
      template<class RandomAccessIterator,
               class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
               class BinaryPredicate = equal_to<>>
      class boyer_moore_horspool_searcher;
      template<class ForwardIterator, class BinaryPredicate = equal_to<>>
      default_searcher<ForwardIterator, BinaryPredicate>
      make_default_searcher(ForwardIterator pat_first, ForwardIterator pat_last,
                            BinaryPredicate pred = BinaryPredicate());
      template<class RandomAccessIterator,
               class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
               class BinaryPredicate = equal_to<>>
      boyer_moore_searcher<RandomAccessIterator, Hash, BinaryPredicate>
      make_boyer_moore_searcher(RandomAccessIterator pat_first,
                                RandomAccessIterator pat_last,
                                Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());
      template<class RandomAccessIterator,
               class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
               class BinaryPredicate = equal_to<>>
      boyer_moore_horspool_searcher<RandomAccessIterator, Hash, BinaryPredicate>
      make_boyer_moore_horspool_searcher(RandomAccessIterator pat_first,
                                         RandomAccessIterator pat_last,
                                         Hash hf = Hash(),
                                         BinaryPredicate pred = BinaryPredicate());

      // hash function primary template:
      template <class T> struct hash;

      // function object binders:
      template <class T> inline constexpr bool is_bind_expression_v
      = is_bind_expression<T>::value;
      template <class T> inline constexpr int is_placeholder_v
      = is_placeholder<T>::value;
    }

#### [edit] Class std::reference_wrapper

    namespace std {
      template <class T> class reference_wrapper {
        public :
        // types
        using type = T;
        // construct/copy/destroy
        reference_wrapper(T&) noexcept;
        reference_wrapper(T&&) = delete; // do not bind to temporary objects
        reference_wrapper(const reference_wrapper& x) noexcept;
        // assignment
        reference_wrapper& operator=(const reference_wrapper& x) noexcept;
        // access
        operator T& () const noexcept;
        T& get() const noexcept;
        // invocation
        template <class... ArgTypes>
        invoke_result_t<T&, ArgTypes...> operator() (ArgTypes&&...) const;
      };
    }

#### [edit] Class std::is_bind_expression

    namespace std {
      template<class T> struct is_bind_expression;
    }

#### [edit] Class std::is_placeholder

    namespace std {
      template<class T> struct is_placeholder;
    }

#### [edit] Class std::bad_function_call

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

#### [edit] Class std::function

    namespace std {
      template<class> class function; // undefined
      template<class R, class... ArgTypes>
      class function<R(ArgTypes...)> {
        public:
        using result_type = R;
        // construct/copy/destroy:
        function() noexcept;
        function(nullptr_t) noexcept;
        function(const function&);
        function(function&&);
        template<class F> function(F);
        function& operator=(const function&);
        function& operator=(function&&);
        function& operator=(nullptr_t) noexcept;
        template<class F> function& operator=(F&&);
        template<class F> function& operator=(reference_wrapper<F>) noexcept;
        ~function();
        // function modifiers:
        void swap(function&) noexcept;
        // function capacity:
        explicit operator bool() const noexcept;
        // function invocation:
        R operator()(ArgTypes...) const;
        // function target access:
        const type_info& target_type() const noexcept;
        template<class T> T* target() noexcept;
        template<class T> const T* target() const noexcept;
      };
      // Null pointer comparisons:
      template <class R, class... ArgTypes>
      bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
      template <class R, class... ArgTypes>
      bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
      template <class R, class... ArgTypes>
      bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
      template <class R, class... ArgTypes>
      bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
      // specialized algorithms:
      template <class R, class... ArgTypes>
      void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
    }

### [edit] See Also

`<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

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/header/functional&oldid=91018"