标准库头文件 <functional>
命名空间
placeholders | 定义了用作 std::bind 表达式中的未绑定实参的占位符 |
常量 | |
定义于命名空间
std::placeholders | |
(C++11) |
用作 std::bind 表达式中的未绑定实参的占位符 (常量) |
类
(C++11) |
包装具有指定函数调用签名的任意类型的可调用对象 (类模板) |
(C++11) |
从成员指针创建出函数对象 (函数模板) |
(C++11) |
调用空的 std::function 时抛出的异常 (类) |
(C++11) |
指示对象为 std::bind 表达式,或能被用作这种表达式 (类模板) |
(C++11) |
表明一个对象是标准占位符,或者可以用作标准占位符 (类模板) |
(C++11) |
可复制构造 (CopyConstructible) 且可复制赋值 (CopyAssignable) 的引用包装器 (类模板) |
散列 | |
(C++11) |
散列函数对象 (类模板) |
template<> struct hash<bool>; |
对内建类型的 std::hash 特化 (类模板特化) |
函数
(C++11) |
绑定一或多个实参到函数对象 (函数模板) |
(C++11)(C++11) |
创建具有从其实参推导的类型的 std::reference_wrapper (函数模板) |
(C++17) |
以给定实参调用任意可调用 (Callable) 对象 (函数模板) |
函数对象
算术运算 | |
实现 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 的函数对象 (类) |
逻辑运算 | |
实现 x && y 的函数对象 (类模板) | |
实现 x || y 的函数对象 (类模板) | |
实现 !x 的函数对象 (类模板) | |
逐位运算 | |
实现 x & y 的函数对象 (类模板) | |
实现 x | y 的函数对象 (类模板) | |
实现 x ^ y 的函数对象 (类模板) | |
(C++14) |
实现 ~x 的函数对象 (类模板) |
取反器 | |
(C++17) |
创建返回其保有的函数对象的结果之补的函数对象 (函数模板) |
搜索器 | |
(C++17) |
标准 C++ 库搜索算法实现 (类模板) |
(C++17) |
Boyer-Moore 搜索算法实现 (类模板) |
Boyer-Moore-Horspool 搜索算法实现 (类模板) |
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...>); // 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; // 算术运算 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>; // identity struct identity; // 函数模板 not_fn template<class F> constexpr /* 未指明 */ not_fn(F&& f); // 函数模板 bind_front template<class F, class... Args> constexpr /* 未指明 */ bind_front(F&&, Args&&...); // bind template<class T> struct is_bind_expression; template<class T> struct is_placeholder; 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; // 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; // 搜索器 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; // 函数对象绑定器 template<class T> inline constexpr bool is_bind_expression_v = is_bind_expression<T>::value; template<class T> inline constexpr int is_placeholder_v = is_placeholder<T>::value; namespace ranges { // 概念制约的比较 struct equal_to; struct not_equal_to; struct greater; struct less; struct greater_equal; struct less_equal; } }
类模板 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& () const noexcept; constexpr T& get() const noexcept; // 调用 template<class... ArgTypes> constexpr invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&...) const; }; 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类 std::ranges::equal_to
namespace std::ranges { struct equal_to { template<class T, class U> requires equality_comparable_with<T, U> || /*BUILTIN-PTR-CMP*/(T, ==, U) constexpr bool 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> requires equality_comparable_with<T, U> || /*BUILTIN-PTR-CMP*/(T, ==, U) constexpr bool operator()(T&& t, U&& u) const; using is_transparent = /* 未指明 */; }; }
类 std::ranges::greater
namespace std::ranges { struct greater { template<class T, class U> requires totally_ordered_with<T, U> || /*BUILTIN-PTR-CMP*/(U, <, T) constexpr bool operator()(T&& t, U&& u) const; using is_transparent = /* 未指明 */; }; }
类 std::ranges::less
namespace std::ranges { struct less { template<class T, class U> requires totally_ordered_with<T, U> || /*BUILTIN-PTR-CMP*/(T, <, U) constexpr bool operator()(T&& t, U&& u) const; using is_transparent = /* 未指明 */; }; }
类 std::ranges::greater_equal
namespace std::ranges { struct greater_equal { template<class T, class U> requires totally_ordered_with<T, U> || /*BUILTIN-PTR-CMP*/(T, <, U) constexpr bool operator()(T&& t, U&& u) const; using is_transparent = /* 未指明 */; }; }
类 std::ranges::less_equal
namespace std::ranges { struct less_equal { template<class T, class U> requires totally_ordered_with<T, U> || /*BUILTIN-PTR-CMP*/(U, <, T) constexpr bool operator()(T&& t, U&& u) const; using is_transparent = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 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 = /* 未指明 */; }; }
类模板 std::identity
namespace std { struct identity { template<class T> constexpr T&& operator()(T&& t) const noexcept; 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] const char* what() const noexcept 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() const noexcept; // function 调用 R operator()(ArgTypes...) const; // function 目标访问 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 */>; // 空指针比较函数 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::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_; // 仅为阐释 }; }
参阅
<string> | 针对 std::string、std::u16string、std::u32string、std::wstring 特化 std::hash |
<system_error> | 针对 std::error_code 特化 std::hash |
<bitset> | 针对 std::bitset 特化 std::hash |
<memory> | 针对 std::unique_ptr、std::shared_ptr 特化 std::hash |
<typeindex> | 针对 std::type_index 特化 std::hash |
<vector> | 针对 std::vector<bool> 特化 std::hash |
<thread> | 针对 std::thread::id 特化 std::hash |