Standard library header <functional>
From cppreference.com
This header is part of the function objects library and provides the standard hash function.
Namespaces | |
| placeholders(C++11) | Provides placeholders for the unbound arguments in a std::bind expression |
Classes | |
Wrappers | |
(C++11) | copyable wrapper of any copy constructible callable object (class template) |
(C++23) | move-only wrapper of any callable object that supports qualifiers in a given call signature (class template) |
(C++26) | copyable wrapper of any copy constructible callable object that supports qualifiers in a given call signature (class template) |
(C++26) | non-owning wrapper of any callable object (class template) |
(C++11) | creates a function object out of a pointer to a member (function template) |
(C++11) | CopyConstructible and CopyAssignable reference wrapper (class template) |
(C++20)(C++20) | get the reference type wrapped in std::reference_wrapper (class template) |
Helper classes | |
(C++11) | the exception thrown when invoking an empty std::function (class) |
(C++11) | indicates that an object is std::bind expression or can be used as one (class template) |
(C++11) | indicates that an object is a standard placeholder or can be used as one (class template) |
Arithmetic operations | |
| function object implementing x + y (class template) | |
| function object implementing x - y (class template) | |
| function object implementing x * y (class template) | |
| function object implementing x / y (class template) | |
| function object implementing x % y (class template) | |
| function object implementing -x (class template) | |
Comparisons | |
| function object implementing x == y (class template) | |
| function object implementing x != y (class template) | |
| function object implementing x > y (class template) | |
| function object implementing x < y (class template) | |
| function object implementing x >= y (class template) | |
| function object implementing x <= y (class template) | |
Concept-constrained comparisons | |
(C++20) | constrained function object implementing x == y (class) |
(C++20) | constrained function object implementing x != y (class) |
(C++20) | constrained function object implementing x > y (class) |
(C++20) | constrained function object implementing x < y (class) |
(C++20) | constrained function object implementing x >= y (class) |
(C++20) | constrained function object implementing x <= y (class) |
(C++20) | constrained function object implementing x <=> y (class) |
Logical operations | |
| function object implementing x && y (class template) | |
| function object implementing x || y (class template) | |
| function object implementing !x (class template) | |
Bitwise operations | |
| function object implementing x & y (class template) | |
| function object implementing x | y (class template) | |
| function object implementing x ^ y (class template) | |
(C++14) | function object implementing ~x (class template) |
Negators | |
(C++17) | creates a function object that returns the complement of the result of the function object it holds (function template) |
Identities | |
(C++20) | function object that returns its argument unchanged (class) |
Searchers | |
(C++17) | standard C++ library search algorithm implementation (class template) |
(C++17) | Boyer-Moore search algorithm implementation (class template) |
| Boyer-Moore-Horspool search algorithm implementation (class template) | |
Hashing | |
(C++11) | hash function object (class template) |
| std::hash specializations for fundamental, enumeration, and pointer types (class template specialization) | |
Constants | |
Defined in namespace std::placeholders | |
(C++11) | placeholders for the unbound arguments in a std::bind expression (constant) |
Functions | |
(C++20)(C++23) | bind a variable number of arguments, in order, to a function object (function template) |
(C++11) | binds one or more arguments to a function object (function template) |
(C++11)(C++11) | creates a std::reference_wrapper with a type deduced from its argument (function template) |
(C++17)(C++23) | invokes any Callable object with given arguments and possibility to specify return type(since C++23) (function template) |
[edit]Deprecated in C++11 and removed in C++17
Base | |
(deprecated in C++11)(removed in C++17) | adaptor-compatible unary function base class (class template) |
(deprecated in C++11)(removed in C++17) | adaptor-compatible binary function base class (class template) |
Binders | |
(deprecated in C++11)(removed in C++17) | function object holding a binary function and one of its arguments (class template) |
(deprecated in C++11)(removed in C++17) | binds one argument to a binary function (function template) |
Function adaptors | |
(deprecated in C++11)(removed in C++17) | adaptor-compatible wrapper for a pointer to unary function (class template) |
(deprecated in C++11)(removed in C++17) | adaptor-compatible wrapper for a pointer to binary function (class template) |
(deprecated in C++11)(removed in C++17) | creates an adaptor-compatible function object wrapper from a pointer to function (function template) |
(deprecated in C++11)(removed in C++17) | wrapper for a pointer to nullary or unary member function, callable with a pointer to object (class template) |
(deprecated in C++11)(removed in C++17) | creates a wrapper from a pointer to member function, callable with a pointer to object (function template) |
(deprecated in C++11)(removed in C++17) | wrapper for a pointer to nullary or unary member function, callable with a reference to object (class template) |
(deprecated in C++11)(removed in C++17) | creates a wrapper from a pointer to member function, callable with a reference to object (function template) |
[edit]Deprecated in C++17 and removed in C++20
Negators | |
(deprecated in C++17)(removed in C++20) | wrapper function object returning the complement of the unary predicate it holds (class template) |
(deprecated in C++17)(removed in C++20) | wrapper function object returning the complement of the binary predicate it holds (class template) |
(deprecated in C++17)(removed in C++20) | constructs custom std::unary_negate object (function template) |
(deprecated in C++17)(removed in C++20) | constructs custom std::binary_negate object (function template) |
[edit]Synopsis
namespace std {// invoketemplate<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_wrappertemplate<class T>class reference_wrapper; template<class T>constexpr reference_wrapper<T> ref(T&)noexcept;template<class T>constexpr 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>constexpr reference_wrapper<T> ref(reference_wrapper<T>)noexcept;template<class T>constexpr reference_wrapper<const T> cref(reference_wrapper<T>)noexcept; template<class T>struct unwrap_reference;template<class T>using unwrap_reference_t =typename unwrap_reference<T>::type;template<class T>struct unwrap_ref_decay;template<class T>using unwrap_ref_decay_t =typename unwrap_ref_decay<T>::type; // common_reference related specializationstemplate<class R, class T, template<class>class RQual, template<class>class TQual> requires /* see below */struct basic_common_reference<R, T, RQual, TQual>; template<class T, class R, template<class>class TQual, template<class>class RQual> requires /* see below */struct basic_common_reference<T, R, TQual, RQual>; // arithmetic operationstemplate<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>; // comparisonstemplate<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 operationstemplate<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 operationstemplate<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>; // identitystruct identity; // function template not_fntemplate<class F>constexpr/* unspecified */ not_fn(F&& f); // function templates bind_front and bind_backtemplate<class F, class... Args>constexpr/* unspecified */ bind_front(F&&, Args&&...);template<class F, class... Args>constexpr/* unspecified */ bind_back(F&&, Args&&...); // bindtemplate<class T>struct is_bind_expression;template<class T>inlineconstexprbool is_bind_expression_v = is_bind_expression<T>::value; template<class T>struct is_placeholder;template<class T>inlineconstexprint is_placeholder_v = is_placeholder<T>::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 adaptorstemplate<class R, class T>constexpr/* unspecified */ mem_fn(R T::*)noexcept; // polymorphic function wrappersclass bad_function_call; template<class>class function;// not definedtemplate<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 wrappertemplate<class...>class move_only_function;// not defined template<class R, class... ArgTypes>class move_only_function<R(ArgTypes...)/*cv ref*/noexcept(/*noex*/)>; // copyable wrappertemplate<class...>class copyable_function;// not defined template<class R, class... ArgTypes>class copyable_function<R(ArgTypes...)/*cv ref*/noexcept(/*noex*/)>; // non-owning wrappertemplate<class...>class function_ref;// not defined template<class R, class... ArgTypes>class function_ref<R(ArgTypes...)/*cv*/noexcept(/*noex*/)>; // searcherstemplate<class ForwardIter, class BinaryPredicate = equal_to<>>class default_searcher; template<class RandomAccessIter, class Hash = hash<typename iterator_traits<RandomAccessIter>::value_type>, class BinaryPredicate = equal_to<>>class boyer_moore_searcher; template<class RandomAccessIter, class Hash = hash<typename iterator_traits<RandomAccessIter>::value_type>, class BinaryPredicate = equal_to<>>class boyer_moore_horspool_searcher; // hash function primary templatetemplate<class T>struct hash; // concept-constrained comparisonsstruct compare_three_way;namespace ranges {struct equal_to;struct not_equal_to;struct greater;struct less;struct greater_equal;struct less_equal;} // exposition onlytemplate<class Fn, class... Args> concept /*callable*/= requires (Fn&& fn, Args&&... args){std::forward<Fn>(fn)(std::forward<Args>(args)...);}; // exposition onlytemplate<class Fn, class... Args> concept /*nothrow-callable*/=/*callable*/<Fn, Args...>&& requires (Fn&& fn, Args&&... args){{std::forward<Fn>(fn)(std::forward<Args>(args)...)}noexcept;}; // exposition onlytemplate<class Fn, class... Args>using/*call-result-t*/= decltype(std::declval<Fn>()(std::declval<Args>()...)); // exposition onlytemplate<constauto& T>using/*decayed-typeof*/= decltype(auto(T));}
[edit]Class template std::reference_wrapper
namespace std {template<class T>class reference_wrapper {public:// typesusing type = T; // construct/copy/destroytemplate<class U>constexpr reference_wrapper(U&&)noexcept(/* see below */);constexpr reference_wrapper(const reference_wrapper& x)noexcept; // assignmentconstexpr reference_wrapper& operator=(const reference_wrapper& x)noexcept; // accessconstexpr operator T&()constnoexcept;constexpr T& get()constnoexcept; // invocationtemplate<class... ArgTypes>constexpr invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&...)constnoexcept(is_nothrow_invocable_v<T&, ArgTypes...>); // comparisonfriendconstexprbool operator==(reference_wrapper, reference_wrapper);friendconstexprbool operator==(reference_wrapper, const T&);friendconstexprbool operator==(reference_wrapper, reference_wrapper<const T>); friendconstexprauto operator<=>(reference_wrapper, reference_wrapper);friendconstexprauto operator<=>(reference_wrapper, const T&);friendconstexprauto operator<=>(reference_wrapper, reference_wrapper<const T>);};// deduction guidestemplate<class T> reference_wrapper(T&)-> reference_wrapper<T>;}
[edit]Class template std::unwrap_reference
namespace std {template<class T>struct unwrap_reference;}
[edit]Class template std::unwrap_ref_decay
namespace std {template<class T>struct unwrap_ref_decay;}
[edit]Class template std::plus
namespace std {template<class T =void>struct plus {constexpr T operator()(const T& x, const T& y)const;}; template<>struct plus<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)+std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::minus
namespace std {template<class T =void>struct minus {constexpr T operator()(const T& x, const T& y)const;}; template<>struct minus<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)-std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::multiplies
namespace std {template<class T =void>struct multiplies {constexpr T operator()(const T& x, const T& y)const;}; template<>struct multiplies<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)*std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::divides
namespace std {template<class T =void>struct divides {constexpr T operator()(const T& x, const T& y)const;}; template<>struct divides<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)/std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::modulus
namespace std {template<class T =void>struct modulus {constexpr T operator()(const T& x, const T& y)const;}; template<>struct modulus<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)%std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::negate
namespace std {template<class T =void>struct negate {constexpr T operator()(const T& x)const;}; template<>struct negate<void>{template<class T>constexprauto operator()(T&& t)const-> decltype(-std::forward<T>(t)); using is_transparent =/* unspecified */;};}
[edit]Class template std::equal_to
namespace std {template<class T =void>struct equal_to {constexprbool operator()(const T& x, const T& y)const;}; template<>struct equal_to<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)==std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::not_equal_to
namespace std {template<class T =void>struct not_equal_to {constexprbool operator()(const T& x, const T& y)const;}; template<>struct not_equal_to<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)!=std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::greater
namespace std {template<class T =void>struct greater {constexprbool operator()(const T& x, const T& y)const;}; template<>struct greater<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)>std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::less
namespace std {template<class T =void>struct less {constexprbool operator()(const T& x, const T& y)const;}; template<>struct less<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)<std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::greater_equal
namespace std {template<class T =void>struct greater_equal {constexprbool operator()(const T& x, const T& y)const;}; template<>struct greater_equal<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)>=std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::less_equal
namespace std {template<class T =void>struct less_equal {constexprbool operator()(const T& x, const T& y)const;}; template<>struct less_equal<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)<=std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class std::compare_three_way
namespace std {struct compare_three_way {template<class T, class U>constexprauto 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>constexprbool 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>constexprbool 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>constexprbool 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>constexprbool 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>constexprbool 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>constexprbool operator()(T&& t, U&& u)const; using is_transparent =/* unspecified */;};}
[edit]Class template std::logical_and
namespace std {template<class T =void>struct logical_and {constexprbool operator()(const T& x, const T& y)const;}; template<>struct logical_and<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)&&std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::logical_or
namespace std {template<class T =void>struct logical_or {constexprbool operator()(const T& x, const T& y)const;}; template<>struct logical_or<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)||std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::logical_not
namespace std {template<class T =void>struct logical_not {constexprbool operator()(const T& x)const;}; template<>struct logical_not<void>{template<class T>constexprauto operator()(T&& t)const-> decltype(!std::forward<T>(t)); using is_transparent =/* unspecified */;};}
[edit]Class template std::bit_and
namespace std {template<class T =void>struct bit_and {constexpr T operator()(const T& x, const T& y)const;}; template<>struct bit_and<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)&std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::bit_or
namespace std {template<class T =void>struct bit_or {constexpr T operator()(const T& x, const T& y)const;}; template<>struct bit_or<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)|std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::bit_xor
namespace std {template<class T =void>struct bit_xor {constexpr T operator()(const T& x, const T& y)const;}; template<>struct bit_xor<void>{template<class T, class U>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)^std::forward<U>(u)); using is_transparent =/* unspecified */;};}
[edit]Class template std::bit_not
namespace std {template<class T =void>struct bit_not {constexpr T operator()(const T& x)const;}; template<>struct bit_not<void>{template<class T>constexprauto operator()(T&& t)const-> decltype(~std::forward<T>(t)); using is_transparent =/* unspecified */;};}
[edit]Class template std::identity
namespace std {struct identity {template<class T>constexpr T&& operator()(T&& t)constnoexcept; using is_transparent =/* unspecified */;};}
[edit]Class template std::is_bind_expression
namespace std {template<class T>struct is_bind_expression;}
[edit]Class template std::is_placeholder
namespace std {template<class T>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 functionsconstchar* what()constnoexcept override;};}
[edit]Class template std::function
namespace std {template<class>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<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 modifiersvoid swap(function&)noexcept; // function capacityexplicit operator bool()constnoexcept; // function invocation R operator()(ArgTypes...)const; // function target accessconst type_info& target_type()constnoexcept;template<class T> T* target()noexcept;template<class T>const T* target()constnoexcept;}; template<class R, class... ArgTypes> function(R(*)(ArgTypes...))-> function<R(ArgTypes...)>; template<class F> function(F)-> function</* see description */>; // null pointer comparison functionstemplate<class R, class... ArgTypes>bool operator==(const function<R(ArgTypes...)>&, nullptr_t)noexcept; // specialized algorithmstemplate<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<class F> move_only_function(F&&); template<class T, class... Args>explicit move_only_function(in_place_type_t<T>, Args&&...);template<class T, class U, class... Args>explicit move_only_function(in_place_type_t<T>, initializer_list<U>, Args&&...); move_only_function& operator=(move_only_function&&); move_only_function& operator=(nullptr_t)noexcept;template<class F> move_only_function& operator=(F&&); ~move_only_function(); // invocationexplicit operator bool()constnoexcept; R operator()(ArgTypes...)/*cv-ref*/noexcept(/*noex*/); // utilityvoid swap(move_only_function&)noexcept; friendvoid swap(move_only_function&, move_only_function&)noexcept; friendbool operator==(const move_only_function&, nullptr_t)noexcept; private:// exposition-onlytemplate<class VT>staticconstexprbool/*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<class F> copyable_function(F&&); template<class T, class... Args>explicit copyable_function(in_place_type_t<T>, Args&&...);template<class T, class U, class... Args>explicit copyable_function(in_place_type_t<T>, initializer_list<U>, Args&&...); copyable_function& operator=(const copyable_function&); copyable_function& operator=(copyable_function&&); copyable_function& operator=(nullptr_t)noexcept;template<class F> copyable_function& operator=(F&&); ~copyable_function(); // invocationexplicit operator bool()constnoexcept; R operator()(ArgTypes...)/*cv-ref*/noexcept(/*noex*/); // utilityvoid swap(copyable_function&)noexcept; friendvoid swap(copyable_function&, copyable_function&)noexcept; friendbool operator==(const copyable_function&, nullptr_t)noexcept; private:// exposition-onlytemplate<class VT>staticconstexprbool/*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 operatorstemplate<class F> function_ref(F*)noexcept;template<class F>constexpr function_ref(F&&)noexcept;template<auto f>constexpr function_ref(nontype_t<f>)noexcept;template<auto f, class U>constexpr function_ref(nontype_t<f>, U&&)noexcept;template<auto f, class T>constexpr function_ref(nontype_t<f>, /*cv*/ T*)noexcept; constexpr function_ref(const function_ref&)noexcept=default;constexpr function_ref& operator=(const function_ref&)noexcept=default;template<class T> function_ref& operator=(T)= delete; // invocation R operator()(ArgTypes...)/*cv*/noexcept(/*noex*/); private:// exposition-onlytemplate<class... T>staticconstexprbool/*is-invocable-using*/=/* see description */; R (*thunk-ptr)(BoundEntityType, ArgTypes&&...)noexcept(/*noex*/);// exposition-only BoundEntityType bound-entity;// exposition-only};// deduction guidestemplate<class F> function_ref(F*)-> function_ref<F>;template<auto f> function_ref(nontype_t<f>)-> function_ref</* see description */>;template<auto f, class T> function_ref(nontype_t<f>, 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<class ForwardIter2>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<RandomAccessIter1>::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<class RandomAccessIter2> 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<RandomAccessIter1>::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<class RandomAccessIter2> 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
| std::hashspecializations for library types |
