# Standard library header <functional>

From cppreference.com
< cpp‎ | header

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

### 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)

### 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)
ref cref (C++11)(C++11) | creates a std::reference_wrapper with a type deduced from its argument (function template)
invoke (C++17) | invokes any `Callable` object with given arguments (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)
bit_not (C++14) | function object implementing ~x (class template)

##### Negators

not_fn (C++17) | Creates a function object that returns the complement of the result of the function object it holds (function template)
unary_negate (deprecated) | wrapper function object returning the complement of the unary predicate it holds (class template)
binary_negate (deprecated) | wrapper function object returning the complement of the binary predicate it holds (class template)
not1 (deprecated) | constructs custom std::unary_negate object (function template)
not2 (deprecated) | constructs custom std::binary_negate object (function template)

##### Searchers

default_searcher (C++17) | standard C++ library search algorithm implementation (class template)
boyer_moore_searcher (C++17) | Boyer-Moore search algorithm implementation (class template)
boyer_moore_horspool_searcher (C++17) | Boyer-Moore-Horspool search algorithm implementation (class template)

### Deprecated in C++11 and removed in C++17

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

binder1st binder2nd (until C++17)(until C++17) | function object holding a binary function and one of its arguments (class template)
bind1st bind2nd (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_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)
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_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)
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 {
      // 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;
    }

#### 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;
      };
    }

#### Class std::is_bind_expression

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

#### Class std::is_placeholder

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

#### Class std::bad_function_call

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

#### 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...)>&);
    }

### 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"