标准库头文件 <functional>
来自 cppreference.com
命名空间 | |
placeholders (C++11) | 为 std::bind 表达式中未绑定的参数提供占位符 |
类 | |
包装器 | |
(C++11) |
任何可复制构造的可调用对象的复制包装器 (类模板) |
(C++23) |
任何在给定调用签名中支持限定符的可调用对象的移动限定包装器 (类模板) |
(C++26) |
任何在给定调用签名中支持限定符的可复制构造的可调用对象的复制包装器 (类模板) |
(C++26) |
任何可调用对象的非拥有包装器 (类模板) |
(C++11) |
从指向成员的指针创建函数对象 (函数模板) |
(C++11) |
CopyConstructible 和 CopyAssignable 引用包装器 (类模板) |
(C++20)(C++20) |
获取包装在 std::reference_wrapper 中的引用类型 (类模板) |
辅助类 | |
(C++11) |
在调用空 std::function 时抛出的异常 (类) |
(C++11) |
指示对象是 std::bind 表达式或可以作为 std::bind 表达式使用(类模板) |
(C++11) |
指示对象是标准占位符或可以作为标准占位符使用 (类模板) |
算术运算 | |
实现 x + y 的函数对象 (类模板) | |
实现 x - y 的函数对象 (类模板) | |
实现 x * y 的函数对象 (类模板) | |
实现 x / y 的函数对象 (类模板) | |
实现 x % y 的函数对象 (类模板) | |
实现 -x 的函数对象 (类模板) | |
比较 | |
实现 x == y 的函数对象 (类模板) | |
实现 x != y 的函数对象 (类模板) | |
实现 x > y 的函数对象 (类模板) | |
实现 x < y 的函数对象 (类模板) | |
实现 x >= y 的函数对象 (类模板) | |
实现 x <= y 的函数对象 (类模板) | |
概念约束比较 | |
(C++20) |
约束函数对象实现 x == y (类) |
(C++20) |
约束函数对象实现 x != y (类) |
(C++20) |
实现 x > y 的受限函数对象 (类) |
(C++20) |
实现 x < y 的受限函数对象 (类) |
(C++20) |
实现 x >= y 的受限函数对象 (类) |
(C++20) |
实现 x <= y 的受限函数对象 (类) |
(C++20) |
实现 x <=> y 的受限函数对象 (类) |
逻辑运算 | |
实现 x && y 的函数对象 (类模板) | |
实现 x || y 的函数对象 (类模板) | |
实现 !x 的函数对象 (类模板) | |
位运算 | |
实现 x & y 的函数对象 (类模板) | |
实现 x | y 的函数对象 (类模板) | |
实现 x ^ y 的函数对象 (类模板) | |
(C++14) |
实现 ~x 的函数对象 (类模板) |
否定器 | |
(C++17) |
创建一个函数对象,返回它所持有的函数对象的結果的补码 (函数模板) |
标识 | |
(C++20) |
返回其参数不变的函数对象 (类) |
搜索器 | |
(C++17) |
标准 C++ 库搜索算法的实现 (类模板) |
(C++17) |
Boyer-Moore 搜索算法的实现 (类模板) |
Boyer-Moore-Horspool 搜索算法的实现 (类模板) | |
哈希 | |
(C++11) |
哈希函数对象 (类模板) |
针对基本类型、枚举类型和指针类型的 std::hash 特化 (类模板特化) | |
常量 | |
在命名空间
std::placeholders 中定义 | |
(C++11) |
std::bind 表达式中未绑定参数的占位符(常量) |
函数 | |
(C++20)(C++23) |
将可变数量的参数按顺序绑定到函数对象 (函数模板) |
(C++11) |
将一个或多个参数绑定到函数对象 (函数模板) |
(C++11)(C++11) |
创建一个从其参数推断类型的 std::reference_wrapper (函数模板) |
(C++17)(C++23) |
使用给定的参数调用任何 Callable 对象 并且可以指定返回值类型(自 C++23 起) (函数模板) |
[编辑] 在 C++11 中已弃用,并在 C++17 中删除
基础 | |
(在 C++11 中已弃用)(在 C++17 中删除) |
适配器兼容的单元函数基类 (类模板) |
(在 C++11 中已弃用)(在 C++17 中删除) |
适配器兼容的二元函数基类 (类模板) |
绑定器 | |
(在 C++11 中已弃用)(在 C++17 中删除) |
包含二元函数及其一个参数的函数对象 (类模板) |
(在 C++11 中已弃用)(在 C++17 中删除) |
将一个参数绑定到二元函数 (函数模板) |
函数适配器 | |
(在 C++11 中已弃用)(在 C++17 中删除) |
针对指向单元函数的指针的适配器兼容的包装器 (类模板) |
(在 C++11 中已弃用)(在 C++17 中删除) |
针对指向二元函数的指针的适配器兼容的包装器 (类模板) |
(在 C++11 中已弃用)(在 C++17 中删除) |
从指向函数的指针创建适配器兼容的函数对象包装器 (函数模板) |
(在 C++11 中已弃用)(在 C++17 中删除) |
针对指向零元或单元成员函数的指针的包装器,可以使用指向对象的指针进行调用 (类模板) |
(在 C++11 中已弃用)(在 C++17 中删除) |
从指向成员函数的指针创建包装器,可以使用指向对象的指针进行调用 (函数模板) |
(在 C++11 中已弃用)(在 C++17 中删除) |
针对指向零元或单元成员函数的指针的包装器,可以使用指向对象的引用进行调用 (类模板) |
(在 C++11 中已弃用)(在 C++17 中删除) |
从指向成员函数的指针创建包装器,可以使用指向对象的引用进行调用 (函数模板) |
[编辑] C++17 中已弃用,C++20 中已删除
否定器 | |
(C++17 中已弃用)(C++20 中已删除) |
返回它所持有的单元谓词的补码的包装函数对象 (类模板) |
(C++17 中已弃用)(C++20 中已删除) |
返回它所持有的二元谓词的补码的包装函数对象 (类模板) |
(C++17 中已弃用)(C++20 中已删除) |
构造自定义 std::unary_negate 对象 (函数模板) |
(C++17 中已弃用)(C++20 中已删除) |
构造自定义 std::binary_negate 对象 (函数模板) |
[编辑] 概要
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 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 specializations template<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 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>; // identity struct identity; // function template not_fn template<class F> 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<class T> struct is_bind_expression; template<class T> inline constexpr bool is_bind_expression_v = is_bind_expression<T>::value; template<class T> struct is_placeholder; template<class T> inline constexpr int 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 adaptors template<class R, class T> constexpr /* unspecified */ mem_fn(R T::*) noexcept; // polymorphic function wrappers class bad_function_call; template<class> 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<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 template template<class T> 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>(fn)(std::forward<Args>(args)...); }; // exposition only template<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 only template<class Fn, class... Args> using /*call-result-t*/ = decltype(std::declval<Fn>()(std::declval<Args>()...)); // exposition only template<const auto& T> using /*decayed-typeof*/ = decltype(auto(T)); }
[编辑] 类模板 std::reference_wrapper
namespace std { template<class T> class reference_wrapper { public: // types using type = T; // construct/copy/destroy template<class U> 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<const T>); friend constexpr auto operator<=>(reference_wrapper, reference_wrapper); friend constexpr auto operator<=>(reference_wrapper, const T&); friend constexpr auto operator<=>(reference_wrapper, reference_wrapper<const T>); }; // deduction guides template<class T> reference_wrapper(T&) -> reference_wrapper<T>; }
[编辑] 类模板 std::unwrap_reference
namespace std { template<class T> struct unwrap_reference; }
[编辑] 类模板 std::unwrap_ref_decay
namespace std { template<class T> struct unwrap_ref_decay; }
[编辑] 类模板 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> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) + std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 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> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) - std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 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> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) * std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 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> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) / std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 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> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) % std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 std::negate
namespace std { template<class T = void> struct negate { constexpr T operator()(const T& x) const; }; template<> struct negate<void> { template<class T> constexpr auto operator()(T&& t) const -> decltype(-std::forward<T>(t)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 std::equal_to
namespace std { template<class T = void> struct equal_to { constexpr bool operator()(const T& x, const T& y) const; }; template<> struct equal_to<void> { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) == std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 std::not_equal_to
namespace std { template<class T = void> struct not_equal_to { constexpr bool operator()(const T& x, const T& y) const; }; template<> struct not_equal_to<void> { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) != std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 std::greater
namespace std { template<class T = void> struct greater { constexpr bool operator()(const T& x, const T& y) const; }; template<> struct greater<void> { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) > std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 std::less
namespace std { template<class T = void> struct less { constexpr bool operator()(const T& x, const T& y) const; }; template<> struct less<void> { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) < std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 std::greater_equal
namespace std { template<class T = void> struct greater_equal { constexpr bool operator()(const T& x, const T& y) const; }; template<> struct greater_equal<void> { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) >= std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 std::less_equal
namespace std { template<class T = void> struct less_equal { constexpr bool operator()(const T& x, const T& y) const; }; template<> struct less_equal<void> { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) <= std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类 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 */; }; }
[编辑] 类 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 */; }; }
[编辑] 类 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 */; }; }
[编辑] 类 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 */; }; }
[编辑] 类 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 */; }; }
[编辑] 类 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 */; }; }
[编辑] 类 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 */; }; }
[编辑] 类模板 std::logical_and
namespace std { template<class T = void> struct logical_and { constexpr bool operator()(const T& x, const T& y) const; }; template<> struct logical_and<void> { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) && std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 std::logical_or
namespace std { template<class T = void> struct logical_or { constexpr bool operator()(const T& x, const T& y) const; }; template<> struct logical_or<void> { template<class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) || std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 std::logical_not
namespace std { template<class T = void> struct logical_not { constexpr bool operator()(const T& x) const; }; template<> struct logical_not<void> { template<class T> constexpr auto operator()(T&& t) const -> decltype(!std::forward<T>(t)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 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> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) & std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 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> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) | std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 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> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) ^ std::forward<U>(u)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 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> constexpr auto operator()(T&& t) const -> decltype(~std::forward<T>(t)); using is_transparent = /* unspecified */; }; }
[编辑] 类模板 std::identity
namespace std { struct identity { template<class T> constexpr T&& operator()(T&& t) const noexcept; using is_transparent = /* unspecified */; }; }
[编辑] 类模板 std::is_bind_expression
namespace std { template<class T> struct is_bind_expression; }
[编辑] 类模板 std::is_placeholder
namespace std { template<class T> struct is_placeholder; }
[编辑] 类 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; }; }
[编辑] 类模板 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 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; }; template<class R, class... ArgTypes> function(R(*)(ArgTypes...)) -> function<R(ArgTypes...)>; template<class F> 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; }
[编辑] 类模板 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(); // 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<class VT> static constexpr bool /*is-callable-from*/ = /* see description */; }; }
[编辑] 类模板 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(); // 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<class VT> static constexpr bool /*is-callable-from*/ = /* see description */; }; }
[编辑] 类模板 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<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-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<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 */>; }
[编辑] 类模板 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 }; }
[编辑] 类模板 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 }; }
[编辑] 类模板 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 }; }
[编辑] 参见
std::hash 库类型特化 |