标准库标头 <functional>

来自cppreference.com
< cpp‎ | header


 
C++
 
标准库头
 

此头文件是函数对象库的一部分并提供标准散列函数。

目录

命名空间

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 表达式，或能被用作这种表达式
(类模板)[编辑]
(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 搜索算法实现
(类模板)[编辑]
(C++17)
 Boyer-Moore-Horspool 搜索算法实现
(类模板)[编辑]
散列
(C++11)
 散列函数对象
(类模板)[编辑]
(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)
 以给定实参和可能指定的返回类型(C++23 起)调用任意可调用(Callable) 对象
(函数模板)[编辑]

[编辑]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 {// 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 相关特化template<class R, class T, template<class>class RQual, template<class>class TQual> requires /* 见下文 */struct basic_common_reference<R, T, RQual, TQual>;   template<class T, class R, template<class>class TQual, template<class>class RQual> requires /* 见下文 */struct basic_common_reference<T, R, TQual, RQual>;   // 算术运算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>;   // 比较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>;   // 逻辑运算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>;   // 逐位运算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>;   // identitystruct identity;   // 函数模板 not_fntemplate<class F>constexpr/* 未指明 */ not_fn(F&& f);   // 函数模板 bind_front 和 bind_backtemplate<class F, class... Args>constexpr/* 未指明 */ bind_front(F&&, Args&&...);template<class F, class... Args>constexpr/* 未指明 */ 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/* 未指明 */ bind(F&&, BoundArgs&&...);template<class R, class F, class... BoundArgs>constexpr/* 未指明 */ bind(F&&, BoundArgs&&...);   namespace placeholders {// M 是实现定义的占位符数/* 见描述 */ _1;/* 见描述 */ _2; . . . /* 见描述 */ _M;}   // 成员函数适配器template<class R, class T>constexpr/* 未指明 */ mem_fn(R T::*)noexcept;   // 多态函数包装class bad_function_call;   template<class>class function;// 不定义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;   // 仅移动包装template<class...>class move_only_function;// 不定义   template<class R, class... ArgTypes>class move_only_function<R(ArgTypes...)/*cv ref*/noexcept(/*noex*/)>;   // 可复制包装template<class...>class copyable_function;// 不定义   template<class R, class... ArgTypes>class copyable_function<R(ArgTypes...)/*cv ref*/noexcept(/*noex*/)>;   // 无所有权包装template<class...>class function_ref;// 不定义   template<class R, class... ArgTypes>class function_ref<R(ArgTypes...)/*cv*/noexcept(/*noex*/)>;   // 搜索器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;   // 散列函数主模板template<class T>struct hash;   // 概念约束的比较struct compare_three_way;namespace ranges {struct equal_to;struct not_equal_to;struct greater;struct less;struct greater_equal;struct less_equal;}   // 仅用于阐释template<class Fn, class... Args> concept /*callable*/= requires (Fn&& fn, Args&&... args){std::forward<Fn>(fn)(std::forward<Args>(args)...);};   // 仅用于阐释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;};   // 仅用于阐释template<class Fn, class... Args>using/*call-result-t*/= decltype(std::declval<Fn>()(std::declval<Args>()...));   // 仅用于阐释template<constauto& T>using/*decayed-typeof*/= decltype(auto(T));}

[编辑]类模板 std::reference_wrapper

namespace std {template<class T>class reference_wrapper {public:// 类型using type = T;   // 构造/复制/析构template<class U>constexpr reference_wrapper(U&&)noexcept(see below);constexpr reference_wrapper(const reference_wrapper& x)noexcept;   // 赋值constexpr reference_wrapper& operator=(const reference_wrapper& x)noexcept;   // 访问constexpr operator T&()constnoexcept;constexpr T& get()constnoexcept;   // 调用template<class... ArgTypes>constexpr invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&...)constnoexcept(is_nothrow_invocable_v<T&, ArgTypes...>);   // 比较friendconstexprbool 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>);};// 推导指引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>constexprauto operator()(T&& t, U&& u)const-> decltype(std::forward<T>(t)+std::forward<U>(u));   using is_transparent =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类 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 =/* 未指明 */;};}

[编辑]类 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 =/* 未指明 */;};}

[编辑]类 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 =/* 未指明 */;};}

[编辑]类 std::ranges::greater

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

[编辑]类 std::ranges::less

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

[编辑]类 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 =/* 未指明 */;};}

[编辑]类 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 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 =/* 未指明 */;};}

[编辑]类模板 std::identity

namespace std {struct identity {template<class T>constexpr T&& operator()(T&& t)constnoexcept;   using is_transparent =/* 未指明 */;};}

[编辑]类模板 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:// 特殊成员函数的规定见 [exception]constchar* what()constnoexcept override;};}

[编辑]类模板 std::function

namespace std {template<class>class function;// 不定义   template<class R, class... ArgTypes>class function<R(ArgTypes...)>{public:using result_type = R;   // 构造/复制/销毁 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 修改器void swap(function&)noexcept;   // function 容量explicit operator bool()constnoexcept;   // function 调用 R operator()(ArgTypes...)const;   // function 目标访问const 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</* 见说明 */>;   // 空指针比较函数template<class R, class... ArgTypes>bool operator==(const function<R(ArgTypes...)>&, nullptr_t)noexcept;   // 特化的算法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;// 不定义   template<class R, class... ArgTypes>class move_only_function<R(ArgTypes...)/*cv-ref*/noexcept(/*noex*/)>{public:using result_type = R;   // 构造/移动/销毁 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();   // 调用explicit operator bool()constnoexcept;   R operator()(ArgTypes...)/*cv-ref*/noexcept(/*noex*/);   // 工具void swap(move_only_function&)noexcept;   friendvoid swap(move_only_function&, move_only_function&)noexcept;   friendbool operator==(const move_only_function&, nullptr_t)noexcept;   private:// 仅用于阐释template<class VT>staticconstexprbool/*is-callable-from*/=/* 见描述 */;};}

[编辑]类模板 std::copyable_function

namespace std {template<class... S>class copyable_function;// 不定义   template<class R, class... ArgTypes>class copyable_function<R(ArgTypes...)/*cv-ref*/noexcept(/*noex*/)>{public:using result_type = R;   // 构造/移动/销毁 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();   // 调用explicit operator bool()constnoexcept;   R operator()(ArgTypes...)/*cv-ref*/noexcept(/*noex*/);   // 工具void swap(copyable_function&)noexcept;   friendvoid swap(copyable_function&, copyable_function&)noexcept;   friendbool operator==(const copyable_function&, nullptr_t)noexcept;   private:// 仅用于阐释template<class VT>staticconstexprbool/*is-callable-from*/=/* 见描述 */;};}

[编辑]类模板 std::function_ref

namespace std {template<class... S>class function_ref;// 不定义   template<class R, class... ArgTypes>class function_ref<R(ArgTypes...)/*cv*/noexcept(/*noex*/)>{public:// 构造函数和赋值运算符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;   // 调用 R operator()(ArgTypes...)/*cv*/noexcept(/*noex*/);   private:// 仅用于阐释template<class... T>staticconstexprbool/*is-invocable-using*/=/* 见描述 */;   R (*thunk-ptr)(BoundEntityType, ArgTypes&&...)noexcept(/*noex*/);// 仅用于阐释 BoundEntityType bound-entity;// 仅用于阐释};// 推导指引template<class F> function_ref(F*)-> function_ref<F>;template<auto f> function_ref(nontype_t<f>)-> function_ref</* 见描述 */>;template<auto f, class T> function_ref(nontype_t<f>, T&&)-> function_ref</* 见描述 */>;}

[编辑]类模板 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_;// 仅为阐释 ForwardIter1 pat_last_;// 仅为阐释 BinaryPredicate pred_;// 仅为阐释};}

[编辑]类模板 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_;// 仅为阐释 RandomAccessIter1 pat_last_;// 仅为阐释 Hash hash_;// 仅为阐释 BinaryPredicate pred_;// 仅为阐释};}

[编辑]类模板 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_;// 仅为阐释 RandomAccessIter1 pat_last_;// 仅为阐释 Hash hash_;// 仅为阐释 BinaryPredicate pred_;// 仅为阐释};}

[编辑]参阅

std::hash库类型特化
来自“https://zh.cppreference.com/mwiki/index.php?title=cpp/header/functional&oldid=92948”
close