# 标准库头文件 <functional>

< cpp‎ | header

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

### 命名空间
`placeholders` (C++11) | 对 std::bind 表达式中的未绑定实参提供占位符
### 类
##### 包装
function (C++11) | 包装具有指定函数调用签名的任意可复制构造类型的可调用对象 (类模板)
move_only_function (C++23) | 包装具有指定函数调用签名的任意类型的可调用对象 (类模板)
mem_fn (C++11) | 从成员指针创建出函数对象 (函数模板)
reference_wrapper (C++11) | 可复制构造 (CopyConstructible) 且可复制赋值 (CopyAssignable) 的引用包装器 (类模板)
##### 辅助类
bad_function_call (C++11) | 调用空的 std::function 时抛出的异常 (类)
is_bind_expression (C++11) | 指示对象为 `std::bind` 表达式，或能被用作这种表达式 (类模板)
is_placeholder (C++11) | 表明一个对象是标准占位符，或者可以用作标准占位符 (类模板)
##### 算术运算
plus | 实现 x + y 的函数对象 (类模板)
minus | 实现 x - y 的函数对象 (类模板)
multiplies | 实现 x * y 的函数对象 (类模板)
divides | 实现 x / y 的函数对象 (类模板)
modulus | 实现 x % y 的函数对象 (类模板)
negate | 实现 -x 的函数对象 (类模板)
##### 比较
equal_to | 实现 x == y 的函数对象 (类模板)
not_equal_to | 实现 x != y 的函数对象 (类模板)
greater | 实现 x > y 的函数对象 (类模板)
less | 实现 x < y 的函数对象 (类模板)
greater_equal | 实现 x >= y 的函数对象 (类模板)
less_equal | 实现 x <= y 的函数对象 (类模板)
##### 概念约束的比较
ranges::equal_to (C++20) | 实现 x == y 的函数对象 (类)
ranges::not_equal_to (C++20) | 实现 x != y 的函数对象 (类)
ranges::greater (C++20) | 实现 x > y 的函数对象 (类)
ranges::less (C++20) | 实现 x < y 的函数对象 (类)
ranges::greater_equal (C++20) | 实现 x >= y 的函数对象 (类)
ranges::less_equal (C++20) | 实现 x <= y 的函数对象 (类)
compare_three_way (C++20) | 实现 x <=> y 的函数对象 (类)
##### 逻辑运算
logical_and | 实现 x && y 的函数对象 (类模板)
logical_or | 实现 x || y 的函数对象 (类模板)
logical_not | 实现 !x 的函数对象 (类模板)
##### 逐位运算
bit_and | 实现 x & y 的函数对象 (类模板)
bit_or | 实现 x | y 的函数对象 (类模板)
bit_xor | 实现 x ^ y 的函数对象 (类模板)
bit_not (C++14) | 实现 ~x 的函数对象 (类模板)
##### 取反器
not_fn (C++17) | 创建返回其保有的函数对象的结果之补的函数对象 (函数模板)
##### 恒等
identity (C++20) | 返回其未修改的参数的函数对象 (类)
##### 搜索器
default_searcher (C++17) | 标准 C++ 库搜索算法实现 (类模板)
boyer_moore_searcher (C++17) | Boyer-Moore 搜索算法实现 (类模板)
boyer_moore_horspool_searcher (C++17) | Boyer-Moore-Horspool 搜索算法实现 (类模板)
##### 散列
hash (C++11) | 散列函数对象 (类模板)
std::hash<Arithmetic>std::hash<Enumeration>std::hash<std::nullptr_t>std::hash<T*> (C++11) | std::hash 对基础、枚举以及指针类型的特化 (类模板特化)
### 常量
定义于命名空间 `std::placeholders`
_1, _2, _3, _4, ... (C++11) | 用作 `std::bind` 表达式中的未绑定实参的占位符 (常量)
### 函数
bind_front (C++20) | 按顺序绑定一定数量的参数到函数对象 (函数模板)
bind (C++11) | 绑定一或多个实参到函数对象 (函数模板)
ref cref (C++11)(C++11) | 创建具有从其实参推导的类型的 std::reference_wrapper (函数模板)
invoke invoke_r (C++17)(C++23) | 以给定实参和可能指定的返回类型 (C++23 起)调用任意可调用 (Callable) 对象 (函数模板)

### C++11 中弃用并于 C++17 移除

##### 基类
unary_function (C++11 中弃用)(C++17 中移除) | 与适配器兼容的一元函数基类 (类模板)
binary_function (C++11 中弃用)(C++17 中移除) | 与适配器兼容的二元函数基类 (类模板)
##### 绑定器
binder1st binder2nd (C++11 中弃用)(C++17 中移除) | 持有一个二元函数及其实参之一的函数对象 (类模板)
bind1st bind2nd (C++11 中弃用)(C++17 中移除) | 将一个实参绑定到二元函数 (函数模板)
##### 函数适配器
pointer_to_unary_function (C++11 中弃用)(C++17 中移除) | 适配器兼容的包装，用于包装一元函数的指针 (类模板)
pointer_to_binary_function (C++11 中弃用)(C++17 中移除) | 适配器兼容的包装，用于包装二元函数的指针 (类模板)
ptr_fun (C++11 中弃用)(C++17 中移除) | 从函数指针创建与适配器兼容的函数对象包装器 (函数模板)
mem_fun_t mem_fun1_t const_mem_fun_t const_mem_fun1_t (C++11 中弃用)(C++17 中移除) | 指向零元或一元成员函数指针的包装器，可以一个对象指针调用 (类模板)
mem_fun (C++11 中弃用)(C++17 中移除) | 从成员函数指针创建包装器，可以一个对象指针调用 (函数模板)
mem_fun_ref_t mem_fun1_ref_t const_mem_fun_ref_t const_mem_fun1_ref_t (C++11 中弃用)(C++17 中移除) | 指向零元或一元成员函数指针的包装器，可以一个对象引用调用 (类模板)
mem_fun_ref (C++11 中弃用)(C++17 中移除) | 从成员函数指针创建包装器，能以一个对象引用调用 (函数模板)

### C++17 中弃用并于 C++20 移除

##### 取反器
unary_negate (C++17 中弃用)(C++20 中移除) | 包装器函数对象，返回所持有的一元谓词的补 (类模板)
binary_negate (C++17 中弃用)(C++20 中移除) | 包装器函数对象，返回所持有的二元谓词的补 (类模板)
not1 (C++17 中弃用)(C++20 中移除) | 构造定制的 std::unary_negate 对象 (函数模板)
not2 (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;

      // 算术运算
      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>
        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>
        constexpr bool operator()(T&& t, U&& u) const;

        using is_transparent = /* 未指明 */;
      };
    }

#### 类 std::ranges::greater

    namespace std::ranges {
      struct greater {
        template<class T, class U>
        constexpr bool operator()(T&& t, U&& u) const;

        using is_transparent = /* 未指明 */;
      };
    }

#### 类 std::ranges::less

    namespace std::ranges {
      struct less {
        template<class T, class 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>
        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>
        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::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();

        // move_only_function 调用
        explicit operator bool() const noexcept;

        R operator()(ArgTypes...) /*cv-ref*/ noexcept(/*noex*/);

        // move_only_function 工具
        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:
        template<class VT>
          static constexpr bool /*is-callable-from*/ = /* 见描述 */; // 仅用于阐释
      };
    }

#### 类模板 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
`<string_view>` | 针对 std::string_view、std::u16string_view、std::u32string_view、std::wstring_view 特化 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
`<optional>` | 针对 std::optional 特化 std::hash
`<variant>` | 针对 std::variant 特化 std::hash
`<coroutine>` | 针对 std::coroutine_handle 特化 std::hash
`<stacktrace>` | 针对 std::stacktrace_entry 及 std::basic_stacktrace 特化 std::hash