Standard library header - cppreference.com (original) (raw)

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

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

[edit] Deprecated in C++17 and removed in C++20

[edit] Synopsis

namespace std { // invoke template<class F, class... Args> constexpr invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) noexcept(is_nothrow_invocable_v<F, Args...>); template<class R, class F, class... Args> constexpr R invoke_r(F&& f, Args&&... args) noexcept(is_nothrow_invocable_r_v<R, F, Args...>);   // reference_wrapper template class reference_wrapper;   template constexpr reference_wrapper ref(T&) noexcept; template constexpr reference_wrapper cref(const T&) noexcept; template void ref(const T&&) = delete; template void cref(const T&&) = delete;   template constexpr reference_wrapper ref(reference_wrapper) noexcept; template constexpr reference_wrapper cref(reference_wrapper) noexcept;   template struct unwrap_reference; template using unwrap_reference_t = typename unwrap_reference::type; template struct unwrap_ref_decay; template using unwrap_ref_decay_t = typename unwrap_ref_decay::type;   // common_reference related specializations template<class R, class T, template class RQual, template class TQual> requires /* see below / struct basic_common_reference<R, T, RQual, TQual>;   template<class T, class R, template class TQual, template class RQual> requires / see below / struct basic_common_reference<T, R, TQual, RQual>;   // arithmetic operations template struct plus; template struct minus; template struct multiplies; template struct divides; template struct modulus; template struct negate; template<> struct plus; template<> struct minus; template<> struct multiplies; template<> struct divides; template<> struct modulus; template<> struct negate;   // comparisons template struct equal_to; template struct not_equal_to; template struct greater; template struct less; template struct greater_equal; template struct less_equal; template<> struct equal_to; template<> struct not_equal_to; template<> struct greater; template<> struct less; template<> struct greater_equal; template<> struct less_equal;   // logical operations template struct logical_and; template struct logical_or; template struct logical_not; template<> struct logical_and; template<> struct logical_or; template<> struct logical_not;   // bitwise operations template struct bit_and; template struct bit_or; template struct bit_xor; template struct bit_not; template<> struct bit_and; template<> struct bit_or; template<> struct bit_xor; template<> struct bit_not;   // identity struct identity;   // function template not_fn template constexpr / unspecified / not_fn(F&& f);   // function templates bind_front and bind_back template<class F, class... Args> constexpr / unspecified / bind_front(F&&, Args&&...); template<class F, class... Args> constexpr / unspecified / bind_back(F&&, Args&&...);   // bind template struct is_bind_expression; template inline constexpr bool is_bind_expression_v = is_bind_expression::value;   template struct is_placeholder; template inline constexpr int is_placeholder_v = is_placeholder::value;   template<class F, class... BoundArgs> constexpr / unspecified / bind(F&&, BoundArgs&&...); template<class R, class F, class... BoundArgs> constexpr / unspecified / bind(F&&, BoundArgs&&...);   namespace placeholders { // M is the implementation-defined number of placeholders / see description / _1; / see description / _2; . . . / see description / _M; }   // member function adaptors template<class R, class T> constexpr / unspecified / mem_fn(R T::) noexcept;   // polymorphic function wrappers class bad_function_call;   template class function; // not defined template<class R, class... ArgTypes> class function<R(ArgTypes...)>;   template<class R, class... ArgTypes> void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;   template<class R, class... ArgTypes> bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;   // move-only wrapper template<class...> class move_only_function; // not defined   template<class R, class... ArgTypes> class move_only_function<R(ArgTypes...) /*cv ref*/ noexcept(/*noex*/)>;   // copyable wrapper template<class...> class copyable_function; // not defined   template<class R, class... ArgTypes> class copyable_function<R(ArgTypes...) /*cv ref*/ noexcept(/*noex*/)>;   // non-owning wrapper template<class...> class function_ref; // not defined   template<class R, class... ArgTypes> class function_ref<R(ArgTypes...) /*cv*/ noexcept(/*noex*/)>;   // searchers template<class ForwardIter, class BinaryPredicate = equal_to<>> class default_searcher;   template<class RandomAccessIter, class Hash = hash<typename iterator_traits::value_type>, class BinaryPredicate = equal_to<>> class boyer_moore_searcher;   template<class RandomAccessIter, class Hash = hash<typename iterator_traits::value_type>, class BinaryPredicate = equal_to<>> class boyer_moore_horspool_searcher;   // hash function primary template template struct hash;   // concept-constrained comparisons struct compare_three_way; namespace ranges { struct equal_to; struct not_equal_to; struct greater; struct less; struct greater_equal; struct less_equal; }   // exposition only template<class Fn, class... Args> concept /callable/ = requires (Fn&& fn, Args&&... args) { std::forward(fn)(std::forward(args)...); };   // exposition only template<class Fn, class... Args> concept /nothrow-callable/ = /callable/<Fn, Args...> && requires (Fn&& fn, Args&&... args) { { std::forward(fn)(std::forward(args)...) } noexcept; };   // exposition only template<class Fn, class... Args> using /call-result-t/ = decltype(std::declval()(std::declval()...));   // exposition only template<const auto& T> using /decayed-typeof/ = decltype(auto(T)); }

[edit] Class template std::reference_wrapper

namespace std { template class reference_wrapper { public: // types using type = T;   // construct/copy/destroy template constexpr reference_wrapper(U&&) noexcept(/* see below */); constexpr reference_wrapper(const reference_wrapper& x) noexcept;   // assignment constexpr reference_wrapper& operator=(const reference_wrapper& x) noexcept;   // access constexpr operator T& () const noexcept; constexpr T& get() const noexcept;   // invocation template<class... ArgTypes> constexpr invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&...) const noexcept(is_nothrow_invocable_v<T&, ArgTypes...>);   // comparison friend constexpr bool operator==(reference_wrapper, reference_wrapper); friend constexpr bool operator==(reference_wrapper, const T&); friend constexpr bool operator==(reference_wrapper, reference_wrapper);   friend constexpr auto operator<=>(reference_wrapper, reference_wrapper); friend constexpr auto operator<=>(reference_wrapper, const T&); friend constexpr auto operator<=>(reference_wrapper, reference_wrapper); }; // deduction guides template reference_wrapper(T&) -> reference_wrapper; }

[edit] Class template std::unwrap_reference

namespace std { template struct unwrap_reference; }

[edit] Class template std::unwrap_ref_decay

namespace std { template struct unwrap_ref_decay; }

[edit] Class template std::plus

namespace std { template struct plus { constexpr T operator()(const T& x, const T& y) const; };   template<> struct plus { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) + std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::minus

namespace std { template struct minus { constexpr T operator()(const T& x, const T& y) const; };   template<> struct minus { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) - std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::multiplies

namespace std { template struct multiplies { constexpr T operator()(const T& x, const T& y) const; };   template<> struct multiplies { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) * std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::divides

namespace std { template struct divides { constexpr T operator()(const T& x, const T& y) const; };   template<> struct divides { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) / std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::modulus

namespace std { template struct modulus { constexpr T operator()(const T& x, const T& y) const; };   template<> struct modulus { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) % std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::negate

namespace std { template struct negate { constexpr T operator()(const T& x) const; };   template<> struct negate { template constexpr auto operator()(T&& t) const -> decltype(-std::forward(t));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::equal_to

namespace std { template struct equal_to { constexpr bool operator()(const T& x, const T& y) const; };   template<> struct equal_to { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) == std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::not_equal_to

namespace std { template struct not_equal_to { constexpr bool operator()(const T& x, const T& y) const; };   template<> struct not_equal_to { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) != std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::greater

namespace std { template struct greater { constexpr bool operator()(const T& x, const T& y) const; };   template<> struct greater { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) > std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::less

namespace std { template struct less { constexpr bool operator()(const T& x, const T& y) const; };   template<> struct less { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) < std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::greater_equal

namespace std { template struct greater_equal { constexpr bool operator()(const T& x, const T& y) const; };   template<> struct greater_equal { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) >= std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::less_equal

namespace std { template struct less_equal { constexpr bool operator()(const T& x, const T& y) const; };   template<> struct less_equal { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) <= std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class std::compare_three_way

namespace std { struct compare_three_way { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const;   using is_transparent = /* unspecified */; }; }

[edit] Class std::ranges::equal_to

namespace std::ranges { struct equal_to { template<class T, class U> constexpr bool operator()(T&& t, U&& u) const;   using is_transparent = /* unspecified */; }; }

[edit] Class std::ranges::not_equal_to

namespace std::ranges { struct not_equal_to { template<class T, class U> constexpr bool operator()(T&& t, U&& u) const;   using is_transparent = /* unspecified */; }; }

[edit] Class std::ranges::greater

namespace std::ranges { struct greater { template<class T, class U> constexpr bool operator()(T&& t, U&& u) const;   using is_transparent = /* unspecified */; }; }

[edit] Class std::ranges::less

namespace std::ranges { struct less { template<class T, class U> constexpr bool operator()(T&& t, U&& u) const;   using is_transparent = /* unspecified */; }; }

[edit] Class std::ranges::greater_equal

namespace std::ranges { struct greater_equal { template<class T, class U> constexpr bool operator()(T&& t, U&& u) const;   using is_transparent = /* unspecified */; }; }

[edit] Class std::ranges::less_equal

namespace std::ranges { struct less_equal { template<class T, class U> constexpr bool operator()(T&& t, U&& u) const;   using is_transparent = /* unspecified */; }; }

[edit] Class template std::logical_and

namespace std { template struct logical_and { constexpr bool operator()(const T& x, const T& y) const; };   template<> struct logical_and { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) && std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::logical_or

namespace std { template struct logical_or { constexpr bool operator()(const T& x, const T& y) const; };   template<> struct logical_or { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) || std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::logical_not

namespace std { template struct logical_not { constexpr bool operator()(const T& x) const; };   template<> struct logical_not { template constexpr auto operator()(T&& t) const -> decltype((t));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::bit_and

namespace std { template struct bit_and { constexpr T operator()(const T& x, const T& y) const; };   template<> struct bit_and { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) & std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::bit_or

namespace std { template struct bit_or { constexpr T operator()(const T& x, const T& y) const; };   template<> struct bit_or { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) | std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::bit_xor

namespace std { template struct bit_xor { constexpr T operator()(const T& x, const T& y) const; };   template<> struct bit_xor { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward(t) ^ std::forward(u));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::bit_not

namespace std { template struct bit_not { constexpr T operator()(const T& x) const; };   template<> struct bit_not { template constexpr auto operator()(T&& t) const -> decltype(~std::forward(t));   using is_transparent = /* unspecified */; }; }

[edit] Class template std::identity

namespace std { struct identity { template constexpr T&& operator()(T&& t) const noexcept;   using is_transparent = /* unspecified */; }; }

[edit] Class template std::is_bind_expression

namespace std { template struct is_bind_expression; }

[edit] Class template std::is_placeholder

namespace std { template struct is_placeholder; }

[edit] Class std::bad_function_call

namespace std { class bad_function_call : public exception { public: // see [exception] for the specification of the special member functions const char* what() const noexcept override; }; }

[edit] Class template std::function

namespace std { template class function; // not defined   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&&) noexcept; template function(F);   function& operator=(const function&); function& operator=(function&&); function& operator=(nullptr_t) noexcept; template function& operator=(F&&); template function& operator=(reference_wrapper) 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 T* target() noexcept; template const T* target() const noexcept; };   template<class R, class... ArgTypes> function(R(*)(ArgTypes...)) -> function<R(ArgTypes...)>;   template function(F) -> function</* see description */>;   // null pointer comparison functions template<class R, class... ArgTypes> bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;   // specialized algorithms template<class R, class... ArgTypes> void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept; }

[edit] Class template std::move_only_function

namespace std { template<class... S> class move_only_function; // not defined   template<class R, class... ArgTypes> class move_only_function<R(ArgTypes...) /cv-ref*/ noexcept(/noex/)> { public: using result_type = R;   // construct/move/destroy move_only_function() noexcept; move_only_function(nullptr_t) noexcept; move_only_function(move_only_function&&) noexcept; template move_only_function(F&&);   template<class T, class... Args> explicit move_only_function(in_place_type_t, Args&&...); template<class T, class U, class... Args> explicit move_only_function(in_place_type_t, initializer_list, Args&&...);   move_only_function& operator=(move_only_function&&); move_only_function& operator=(nullptr_t) noexcept; template move_only_function& operator=(F&&);   ~move_only_function();   // invocation explicit operator bool() const noexcept;   R operator()(ArgTypes...) /cv-ref/ noexcept(/noex/);   // utility void swap(move_only_function&) noexcept;   friend void swap(move_only_function&, move_only_function&) noexcept;   friend bool operator==(const move_only_function&, nullptr_t) noexcept;   private: // exposition-only template static constexpr bool /is-callable-from/ = / see description */; }; }

[edit] Class template std::copyable_function

namespace std { template<class... S> class copyable_function; // not defined   template<class R, class... ArgTypes> class copyable_function<R(ArgTypes...) /cv-ref*/ noexcept(/noex/)> { public: using result_type = R;   // construct/move/destroy copyable_function() noexcept; copyable_function(nullptr_t) noexcept; copyable_function(const copyable_function&); copyable_function(copyable_function&&) noexcept; template copyable_function(F&&);   template<class T, class... Args> explicit copyable_function(in_place_type_t, Args&&...); template<class T, class U, class... Args> explicit copyable_function(in_place_type_t, initializer_list, Args&&...);   copyable_function& operator=(const copyable_function&); copyable_function& operator=(copyable_function&&); copyable_function& operator=(nullptr_t) noexcept; template copyable_function& operator=(F&&);   ~copyable_function();   // invocation explicit operator bool() const noexcept;   R operator()(ArgTypes...) /cv-ref/ noexcept(/noex/);   // utility void swap(copyable_function&) noexcept;   friend void swap(copyable_function&, copyable_function&) noexcept;   friend bool operator==(const copyable_function&, nullptr_t) noexcept;   private: // exposition-only template static constexpr bool /is-callable-from/ = / see description */; }; }

[edit] Class template std::function_ref

namespace std { template<class... S> class function_ref; // not defined   template<class R, class... ArgTypes> class function_ref<R(ArgTypes...) /cv*/ noexcept(/noex/)> { public: // constructors and assignment operators template function_ref(F) noexcept; template constexpr function_ref(F&&) noexcept; template constexpr function_ref(nontype_t) noexcept; template<auto f, class U> constexpr function_ref(nontype_t, U&&) noexcept; template<auto f, class T> constexpr function_ref(nontype_t, /cv/ T*) noexcept;   constexpr function_ref(const function_ref&) noexcept = default; constexpr function_ref& operator=(const function_ref&) noexcept = default; template function_ref& operator=(T) = delete;   // invocation R operator()(ArgTypes...) /cv/ noexcept(/noex/);   private: // exposition-only template<class... T> static constexpr bool /is-invocable-using/ = /* see description */;   R (thunk-ptr)(BoundEntityType, ArgTypes&&...) noexcept(/noex/); // exposition-only BoundEntityType bound-entity; // exposition-only }; // deduction guides template function_ref(F) -> function_ref; template function_ref(nontype_t) -> function_ref</* see description */>; template<auto f, class T> function_ref(nontype_t, T&&) -> function_ref</* see description */>; }

[edit] Class template std::default_searcher

namespace std { template<class ForwardIter1, class BinaryPredicate = equal_to<>> class default_searcher { public: constexpr default_searcher(ForwardIter1 pat_first, ForwardIter1 pat_last, BinaryPredicate pred = BinaryPredicate());   template constexpr pair<ForwardIter2, ForwardIter2> operator()(ForwardIter2 first, ForwardIter2 last) const;   private: ForwardIter1 pat_first_; // exposition only ForwardIter1 pat_last_; // exposition only BinaryPredicate pred_; // exposition only }; }

[edit] Class template std::boyer_moore_searcher

namespace std { template<class RandomAccessIter1, class Hash = hash<typename iterator_traits::value_type>, class BinaryPredicate = equal_to<>> class boyer_moore_searcher { public: boyer_moore_searcher(RandomAccessIter1 pat_first, RandomAccessIter1 pat_last, Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());   template pair<RandomAccessIter2, RandomAccessIter2> operator()(RandomAccessIter2 first, RandomAccessIter2 last) const;   private: RandomAccessIter1 pat_first_; // exposition only RandomAccessIter1 pat_last_; // exposition only Hash hash_; // exposition only BinaryPredicate pred_; // exposition only }; }

[edit] Class template std::boyer_moore_horspool_searcher

namespace std { template<class RandomAccessIter1, class Hash = hash<typename iterator_traits::value_type>, class BinaryPredicate = equal_to<>> class boyer_moore_horspool_searcher { public: boyer_moore_horspool_searcher(RandomAccessIter1 pat_first, RandomAccessIter1 pat_last, Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());   template pair<RandomAccessIter2, RandomAccessIter2> operator()(RandomAccessIter2 first, RandomAccessIter2 last) const;   private: RandomAccessIter1 pat_first_; // exposition only RandomAccessIter1 pat_last_; // exposition only Hash hash_; // exposition only BinaryPredicate pred_; // exposition only }; }

[edit] See also