标准库头文件 <functional>

来自cppreference.com
< cpp‎ | header
 
 
 

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

目录

[编辑] 命名空间

placeholders 定义了用作 std::bind 表达式中的未绑定实参的占位符
常量
定义于命名空间 std::placeholders
用作 std::bind 表达式中的未绑定实参的占位符
(常量) [编辑]

[编辑]

(C++11)
包装具有指定函数调用签名的任意类型的可调用对象
(类模板) [编辑]
(C++11)
从成员指针创建出函数对象
(函数模板) [编辑]
调用空的 std::function 时抛出的异常
(类) [编辑]
指示对象为 std::bind 表达式,或能被用作这种表达式
(类模板) [编辑]
表明一个对象是标准占位符,或者可以用作标准占位符
(类模板) [编辑]
可复制构造 (CopyConstructible) 可复制赋值 (CopyAssignable) 的引用包装器
(类模板) [编辑]
散列
(C++11)
散列函数对象
(类模板) [编辑]

template<> struct hash<bool>;
template<> struct hash<char>;
template<> struct hash<signed char>;
template<> struct hash<unsigned char>;
template<> struct hash<char16_t>;
template<> struct hash<char32_t>;
template<> struct hash<wchar_t>;
template<> struct hash<short>;
template<> struct hash<unsigned short>;
template<> struct hash<int>;
template<> struct hash<unsigned int>;
template<> struct hash<long>;
template<> struct hash<long long>;
template<> struct hash<unsigned long>;
template<> struct hash<unsigned long long>;
template<> struct hash<float>;
template<> struct hash<double>;
template<> struct hash<long double>;
template< class T > struct hash<T*>;

对内建类型的 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 的函数对象
(类模板) [编辑]
概念制约的比较
实现 x == y 的函数对象
(类) [编辑]
实现 x != y 的函数对象
(类) [编辑]
实现 x > y 的函数对象
(类) [编辑]
实现 x < y 的函数对象
(类) [编辑]
实现 x >= y 的函数对象
(类) [编辑]
实现 x <= y 的函数对象
(类) [编辑]
逻辑运算
实现 x && y 的函数对象
(类模板) [编辑]
实现 x || y 的函数对象
(类模板) [编辑]
实现 !x 的函数对象
(类模板) [编辑]
逐位运算
实现 x & y 的函数对象
(类模板) [编辑]
实现 x | y 的函数对象
(类模板) [编辑]
实现 x ^ y 的函数对象
(类模板) [编辑]
(C++14)
实现 ~x 的函数对象
(类模板) [编辑]
取反器
(C++17)
创建返回其保有的函数对象的结果之补的函数对象
(函数模板) [编辑]
搜索器
标准 C++ 库搜索算法实现
(类模板) [编辑]
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++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::stringstd::u16stringstd::u32stringstd::wstring 特化 std::hash
<system_error> 针对 std::error_code 特化 std::hash
<bitset> 针对 std::bitset 特化 std::hash
<memory> 针对 std::unique_ptrstd::shared_ptr 特化 std::hash
<typeindex> 针对 std::type_index 特化 std::hash
<vector> 针对 std::vector<bool> 特化 std::hash
<thread> 针对 std::thread::id 特化 std::hash