23 General utilities library [utilities]

23.14 Function objects [function.objects]

A function object type - это object type тип, который может быть типом postfix-expressionв вызове функции ([expr.call], [over.match.call]).222 A function object - объект типа функционального объекта. В тех местах, где можно было бы ожидать передачи указателя на функцию в алгоритмический шаблон (пункт [algorithms]), указывается интерфейс для приема объекта функции. Это не только заставляет алгоритмические шаблоны работать с указателями на функции, но также позволяет им работать с произвольными объектами функций.

222)

Такой тип является указателем на функцию или типом класса, который имеет член operator() или тип класса, который имеет преобразование в указатель на функцию.

23.14.1 Header <functional> synopsis [functional.syn]

namespace std {
  // [func.invoke], invoke
  template <class F, class... Args>
    invoke_result_t<F, Args...> invoke(F&& f, Args&&... args)
      noexcept(is_nothrow_invocable_v<F, Args...>);

  // [refwrap], reference_wrapper
  template <class T> class reference_wrapper;

  template <class T> reference_wrapper<T> ref(T&) noexcept;
  template <class T> 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> reference_wrapper<T> ref(reference_wrapper<T>) noexcept;
  template <class T> reference_wrapper<const T> cref(reference_wrapper<T>) noexcept;

  // [arithmetic.operations], 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], 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], 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], 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>;

  // [func.not_fn], function template not_fn
  template <class F>
    unspecified not_fn(F&& f);

  // [func.bind], bind
  template<class T> struct is_bind_expression;
  template<class T> struct is_placeholder;

  template<class F, class... BoundArgs>
    unspecified bind(F&&, BoundArgs&&...);
  template<class R, class F, class... BoundArgs>
    unspecified bind(F&&, BoundArgs&&...);

  namespace placeholders {
    // M is the implementation-defined number of placeholders
    see below _1;
    see below _2;
               .
               .
               .
    see below _M;
  }

  // [func.memfn], member function adaptors
  template<class R, class T>
    unspecified mem_fn(R T::*) noexcept;

  // [func.wrap], 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;
  template<class R, class... ArgTypes>
    bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
  template<class R, class... ArgTypes>
    bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
  template<class R, class... ArgTypes>
    bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;

  // [func.search], searchers
  template<class ForwardIterator, class BinaryPredicate = equal_to<>>
    class default_searcher;

  template<class RandomAccessIterator,
           class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
           class BinaryPredicate = equal_to<>>
    class boyer_moore_searcher;

  template<class RandomAccessIterator,
           class Hash = hash<typename iterator_traits<RandomAccessIterator>::value_type>,
           class BinaryPredicate = equal_to<>>
    class boyer_moore_horspool_searcher;

  // [unord.hash], hash function primary template
  template <class T>
    struct hash;

  // [func.bind], function object binders
  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;
}

[ Example: Если C ++ программа хочет иметь поэлементное сложение двух векторов a и b содержащее double и поместить результат в aэто можно сделать:

transform(a.begin(), a.end(), b.begin(), a.begin(), plus<double>());

— end example ]

[ Example: Чтобы отрицать каждый элемент a:

transform(a.begin(), a.end(), a.begin(), negate<double>());

— end example ]

23.14.2 Definitions [func.def]

К этому пункту применяются следующие определения:

A call signature - это имя возвращаемого типа, за которым следует список в скобках, разделенных запятыми, из нуля или более типов аргументов.

A callable type - это function object type указатель на член.

A callable object - объект вызываемого типа.

A call wrapper type - это тип, который содержит вызываемый объект и поддерживает операцию вызова, которая перенаправляет на этот объект.

A call wrapper - объект типа обертки вызова.

A target object - это вызываемый объект, удерживаемый оболочкой вызова.

23.14.3 Requirements [func.require]

Определите INVOKE(f, t1, t2, ..., tN) следующее:

(1.1)
(t1.*f)(t2, ..., tN) when f - указатель на функцию-член класса T и is_base_of_v<T, decay_t<decltype(t1)>> is true;
(1.2)
(t1.get().*f)(t2, ..., tN) when f - указатель на функцию-член класса T и decay_t<decltype(t1)> является специализацией reference_wrapper;
(1.3)
((*t1).*f)(t2, ..., tN) when f является указателем на функцию-член класса T и t1 не удовлетворяет двум предыдущим элементам;
(1.4)
t1.*f когда N == 1 и f является указателем на член данных класса T и is_base_of_v<T, decay_t<decltype(t1)>> является true;
(1.5)
t1.get().*f когда N == 1 и f является указателем на член данных класса T и decay_t<decltype(t1)> является специализацией reference_wrapper;
(1.6)
(*t1).*f когда N == 1 и f является указателем на член данных класса T и t1 не удовлетворяет двум предыдущим элементам;
(1.7)
f(t1, t2, ..., tN) во всех остальных случаях.

Определите INVOKE<R>(f, t1, t2, ..., tN) как static_cast<void>(INVOKE(f, t1, t2, ..., tN)) если бы R есть cv void, иначе INVOKE(f, t1, t2, ..., tN) неявно преобразовать в R.

Каждый call wrapper должен быть MoveConstructible. A forwarding call wrapper - это оболочка вызова, которая может быть вызвана с произвольным списком аргументов и доставляет аргументы обернутому вызываемому объекту в виде ссылок. Этот шаг пересылки должен гарантировать, что аргументы rvalue доставляются как ссылки rvalue, а аргументы lvalue доставляются как ссылки lvalue. A simple call wrapper - это оболочка переадресации вызовов, которая есть CopyConstructible и, CopyAssignable чей конструктор копирования, конструктор перемещения и оператор присваивания не генерируют исключения. [ Note: В типичной реализации оболочки переадресации вызовов имеют перегруженный оператор вызова функции вида

template<class... UnBoundArgs>
R operator()(UnBoundArgs&&... unbound_args) cv-qual;

— end note ]

23.14.4 Function template invoke [func.invoke]

template <class F, class... Args> invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) noexcept(is_nothrow_invocable_v<F, Args...>);

Returns: INVOKE(std::forward<F>(f), std::forward<Args>(args)...) ([func.require]).

23.14.5 Class template reference_wrapper [refwrap]

namespace std {
  template <class T> class reference_wrapper {
  public :
    // types
    using type = T;

    // construct/copy/destroy
    reference_wrapper(T&) noexcept;
    reference_wrapper(T&&) = delete;     // do not bind to temporary objects
    reference_wrapper(const reference_wrapper& x) noexcept;

    // assignment
    reference_wrapper& operator=(const reference_wrapper& x) noexcept;

    // access
    operator T& () const noexcept;
    T& get() const noexcept;

    // invocation
    template <class... ArgTypes>
      invoke_result_t<T&, ArgTypes...>
      operator() (ArgTypes&&...) const;
  };

  template<class T>
    reference_wrapper(reference_wrapper<T>) -> reference_wrapper<T>;
}

reference_wrapper<T> - это CopyConstructible и CopyAssignable оболочка вокруг ссылки на объект или функцию типа T.

reference_wrapper<T> должен быть trivially copyable type.

23.14.5.1 reference_wrapper construct/copy/destroy [refwrap.const]

reference_wrapper(T& t) noexcept;

Effects: Создает reference_wrapper объект, хранящий ссылку на t.

reference_wrapper(const reference_wrapper& x) noexcept;

Effects: Создает reference_wrapper объект, хранящий ссылку на x.get().

23.14.5.2 reference_wrapper assignment [refwrap.assign]

reference_wrapper& operator=(const reference_wrapper& x) noexcept;

Postconditions: *this хранит ссылку на x.get().

23.14.5.3 reference_wrapper access [refwrap.access]

operator T& () const noexcept;

Returns: Сохраненная ссылка.

T& get() const noexcept;

Returns: Сохраненная ссылка.

23.14.5.4 reference_wrapper invocation [refwrap.invoke]

template <class... ArgTypes> invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&... args) const;

Returns: INVOKE(get(), std::forward<ArgTypes>(args)...). ([func.require])

23.14.5.5 reference_wrapper helper functions [refwrap.helpers]

template <class T> reference_wrapper<T> ref(T& t) noexcept;

Returns: reference_wrapper<T>(t).

template <class T> reference_wrapper<T> ref(reference_wrapper<T> t) noexcept;

Returns: ref(t.get()).

template <class T> reference_wrapper<const T> cref(const T& t) noexcept;

Returns: reference_wrapper <const T>(t).

template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;

Returns: cref(t.get()).

23.14.6 Arithmetic operations [arithmetic.operations]

Библиотека предоставляет базовые классы функциональных объектов для всех арифметических операторов языка ([expr.mul], [expr.add]).

23.14.6.1 Class template plus [arithmetic.operations.plus]

template <class T = void> struct plus { constexpr T operator()(const T& x, const T& y) const; };

constexpr T operator()(const T& x, const T& y) const;

Returns: x + y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) + std::forward(u));

Returns: std::forward<T>(t) + std::forward(u).

23.14.6.2 Class template minus [arithmetic.operations.minus]

template <class T = void> struct minus { constexpr T operator()(const T& x, const T& y) const; };

constexpr T operator()(const T& x, const T& y) const;

Returns: x - y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) - std::forward(u));

Returns: std::forward<T>(t) - std::forward(u).

23.14.6.3 Class template multiplies [arithmetic.operations.multiplies]

template <class T = void> struct multiplies { constexpr T operator()(const T& x, const T& y) const; };

constexpr T operator()(const T& x, const T& y) const;

Returns: x * y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) * std::forward(u));

Returns: std::forward<T>(t) * std::forward(u).

23.14.6.4 Class template divides [arithmetic.operations.divides]

template <class T = void> struct divides { constexpr T operator()(const T& x, const T& y) const; };

constexpr T operator()(const T& x, const T& y) const;

Returns: x / y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) / std::forward(u));

Returns: std::forward<T>(t) / std::forward(u).

23.14.6.5 Class template modulus [arithmetic.operations.modulus]

template <class T = void> struct modulus { constexpr T operator()(const T& x, const T& y) const; };

constexpr T operator()(const T& x, const T& y) const;

Returns: x % y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) % std::forward(u));

Returns: std::forward<T>(t) % std::forward(u).

23.14.6.6 Class template negate [arithmetic.operations.negate]

template <class T = void> struct negate { constexpr T operator()(const T& x) const; };

constexpr T operator()(const T& x) const;

Returns: -x.

template <> struct negate<void> { template <class T> constexpr auto operator()(T&& t) const -> decltype(-std::forward<T>(t)); using is_transparent = unspecified; };

template <class T> constexpr auto operator()(T&& t) const -> decltype(-std::forward<T>(t));

Returns: -std::forward<T>(t).

23.14.7 Comparisons [comparisons]

Библиотека предоставляет базовые классы объектов функций для всех операторов сравнения на языке ([expr.rel], [expr.eq]).

Для шаблонов less, greater, less_equalи greater_equal, специализации для любого типа указателя дают строгий общий порядок , который соответствует числу тех специальностей , а также в соответствии с частичным порядком наложенного с помощью встроенного в операторах <, >, <=, >=. [ Note: Когда a (a, b), (a > b) == greater(a, b)и так далее. ] Для шаблонных специализаций , , и , если оператор вызова вызывает встроенный оператор сравнения указателей, оператор вызова дает строгий общий порядок , который соответствует числу тех специализаций и также соответствует частичному порядка , навязанному тем встроенному операторы. — end note less<void> greater<void>less_equal<void> greater_equal<void>

23.14.7.1 Class template equal_to [comparisons.equal_to]

template <class T = void> struct equal_to { constexpr bool operator()(const T& x, const T& y) const; };

constexpr bool operator()(const T& x, const T& y) const;

Returns: x == y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) == std::forward(u));

Returns: std::forward<T>(t) == std::forward(u).

23.14.7.2 Class template not_equal_to [comparisons.not_equal_to]

template <class T = void> struct not_equal_to { constexpr bool operator()(const T& x, const T& y) const; };

constexpr bool operator()(const T& x, const T& y) const;

Returns: x != y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) != std::forward(u));

Returns: std::forward<T>(t) != std::forward(u).

23.14.7.3 Class template greater [comparisons.greater]

template <class T = void> struct greater { constexpr bool operator()(const T& x, const T& y) const; };

constexpr bool operator()(const T& x, const T& y) const;

Returns: x > y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) > std::forward(u));

Returns: std::forward<T>(t) > std::forward(u).

23.14.7.4 Class template less [comparisons.less]

template <class T = void> struct less { constexpr bool operator()(const T& x, const T& y) const; };

constexpr bool operator()(const T& x, const T& y) const;

Returns: x < y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) < std::forward(u));

Returns: std::forward<T>(t) < std::forward(u).

23.14.7.5 Class template greater_equal [comparisons.greater_equal]

template <class T = void> struct greater_equal { constexpr bool operator()(const T& x, const T& y) const; };

constexpr bool operator()(const T& x, const T& y) const;

Returns: x >= y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) >= std::forward(u));

Returns: std::forward<T>(t) >= std::forward(u).

23.14.7.6 Class template less_equal [comparisons.less_equal]

template <class T = void> struct less_equal {
  constexpr bool operator()(const T& x, const T& y) const;
};

constexpr bool operator()(const T& x, const T& y) const;

Returns: x <= y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) <= std::forward(u));

Returns: std::forward<T>(t) <= std::forward(u).

23.14.8 Logical operations [logical.operations]

Библиотека содержит основные классы объектов функции для всех логических операторов в языке ([expr.log.and], [expr.log.or], [expr.unary.op]).

23.14.8.1 Class template logical_and [logical.operations.and]

template <class T = void> struct logical_and {
  constexpr bool operator()(const T& x, const T& y) const;
};

constexpr bool operator()(const T& x, const T& y) const;

Returns: x && y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) && std::forward(u));

Returns: std::forward<T>(t) && std::forward(u).

23.14.8.2 Class template logical_or [logical.operations.or]

template <class T = void> struct logical_or {
  constexpr bool operator()(const T& x, const T& y) const;
};

constexpr bool operator()(const T& x, const T& y) const;

Returns: x || y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) || std::forward(u));

Returns: std::forward<T>(t) || std::forward(u).

23.14.8.3 Class template logical_not [logical.operations.not]

template <class T = void> struct logical_not {
  constexpr bool operator()(const T& x) const;
};

constexpr bool operator()(const T& x) const;

Returns: !x.

template <> struct logical_not<void> { template <class T> constexpr auto operator()(T&& t) const -> decltype(!std::forward<T>(t)); using is_transparent = unspecified; };

template <class T> constexpr auto operator()(T&& t) const -> decltype(!std::forward<T>(t));

Returns: !std::forward<T>(t).

23.14.9 Bitwise operations [bitwise.operations]

Библиотека содержит основные классы объектов функции для всех операторов поразрядных на языке ([expr.bit.and], [expr.or], [expr.xor], [expr.unary.op]).

23.14.9.1 Class template bit_and [bitwise.operations.and]

template <class T = void> struct bit_and {
  constexpr T operator()(const T& x, const T& y) const;
};

constexpr T operator()(const T& x, const T& y) const;

Returns: x & y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) & std::forward(u));

Returns: std::forward<T>(t) & std::forward(u).

23.14.9.2 Class template bit_or [bitwise.operations.or]

template <class T = void> struct bit_or {
  constexpr T operator()(const T& x, const T& y) const;
};

constexpr T operator()(const T& x, const T& y) const;

Returns: x | y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) | std::forward(u));

Returns: std::forward<T>(t) | std::forward(u).

23.14.9.3 Class template bit_xor [bitwise.operations.xor]

template <class T = void> struct bit_xor {
  constexpr T operator()(const T& x, const T& y) const;
};

constexpr T operator()(const T& x, const T& y) const;

Returns: x ^ y.

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)); using is_transparent = unspecified; };

template <class T, class U> constexpr auto operator()(T&& t, U&& u) const -> decltype(std::forward<T>(t) ^ std::forward(u));

Returns: std::forward<T>(t) ^ std::forward(u).

23.14.9.4 Class template bit_not [bitwise.operations.not]

template <class T = void> struct bit_not { constexpr T operator()(const T& x) const; };

constexpr T operator()(const T& x) const;

Returns: ~x.

template <> struct bit_not<void> { template <class T> constexpr auto operator()(T&& t) const -> decltype(~std::forward<T>(t)); using is_transparent = unspecified; };

template <class T> constexpr auto operator()(T&&) const -> decltype(~std::forward<T>(t));

Returns: ~std::forward<T>(t).

23.14.10 Function template not_fn [func.not_fn]

template <class F> unspecified not_fn(F&& f);

Effects: Эквивалентен return call_wrapper(std::forward<F>(f)); where call_wrapper класс только для показа, определенный следующим образом:

class call_wrapper {
  using FD = decay_t<F>;
  FD fd;

  explicit call_wrapper(F&& f);

public:
  call_wrapper(call_wrapper&&) = default;
  call_wrapper(const call_wrapper&) = default;

  template<class... Args>
    auto operator()(Args&&...) &
      -> decltype(!declval<invoke_result_t<FD&, Args...>>());

  template<class... Args>
    auto operator()(Args&&...) const&
      -> decltype(!declval<invoke_result_t<const FD&, Args...>>());

  template<class... Args>
    auto operator()(Args&&...) &&
      -> decltype(!declval<invoke_result_t<FD, Args...>>());

  template<class... Args>
    auto operator()(Args&&...) const&&
      -> decltype(!declval<invoke_result_t<const FD, Args...>>());
};

explicit call_wrapper(F&& f);

Requires: FD должны удовлетворять требованиям MoveConstructible. is_constructible_v<FD, F> будет true. fd должен быть callable object.

Effects: Инициализируется fd из std::forward<F>(f).

Throws: Любое исключение, созданное при построении fd.

template<class... Args> auto operator()(Args&&... args) & -> decltype(!declval<invoke_result_t<FD&, Args...>>()); template<class... Args> auto operator()(Args&&... args) const& -> decltype(!declval<invoke_result_t<const FD&, Args...>>());

Effects: Эквивалентен:

return !INVOKE(fd, std::forward<Args>(args)...);              // see [func.require]

template<class... Args> auto operator()(Args&&... args) && -> decltype(!declval<invoke_result_t<FD, Args...>>()); template<class... Args> auto operator()(Args&&... args) const&& -> decltype(!declval<invoke_result_t<const FD, Args...>>());

Effects: Эквивалентен:

return !INVOKE(std::move(fd), std::forward<Args>(args)...);   // see [func.require]

23.14.11 Function object binders [func.bind]

В этом подпункте описывается унифицированный механизм привязки аргументов вызываемых объектов.

23.14.11.1 Class template is_bind_expression [func.bind.isbind]

namespace std {
  template<class T> struct is_bind_expression;  // see below
}

Шаблон класса is_bind_expression можно использовать для обнаружения функциональных объектов, сгенерированных bind. Шаблон функции bind используется is_bind_expression для обнаружения подвыражений.

Экземпляры is_bind_expression шаблона должны соответствовать UnaryTypeTrait требованиям. Реализация должна предоставлять определение, которое имеет базовую характеристику true_type if T является типом, возвращаемым из bind, в противном случае он должен иметь базовую характеристику false_type. Программа может специализировать этот шаблон для определяемого пользователем типа, T чтобы он имел базовую характеристику, true_type указывающую, что T следует рассматривать как подвыражение в bind вызове.

23.14.11.2 Class template is_placeholder [func.bind.isplace]

namespace std {
  template<class T> struct is_placeholder;      // see below
}

Шаблон класса is_placeholder может быть использован для обнаружения стандартных заполнителей _1, _2и так далее. Шаблон функции bind используется is_placeholder для обнаружения заполнителей.

Экземпляры is_placeholder шаблона должны соответствовать UnaryTypeTrait требованиям. Реализация должна предоставлять определение, которое имеет базовую характеристику integral_constant<int, J> if T is the type std::placeholders::_J, в противном случае оно должно иметь базовую характеристику integral_constant<int, 0>. Программа может специализировать этот шаблон для определяемого пользователем типа, T чтобы он имел базовую характеристику integral_constant<int, N> with, N > 0 чтобы указать, что он T должен рассматриваться как тип-заполнитель.

23.14.11.3 Function template bind [func.bind.bind]

В следующем тексте:

(1.1)
FD это тип decay_t<F>,
(1.2)
fd является l-значением типа, FD построенным из std::forward<F>(f),
(1.3)
$T_{i}$ это $i^{th}$ тип в пакете параметров шаблона BoundArgs,
(1.4)
${TD}_{i}$ это тип decay_t< $T_{i}$ >,
(1.5)
$t_{i}$ является $i^{th}$ аргументом в параметре функции пакета bound_args,
(1.6)
${td}_{i}$ является l-значением типа, ${TD}_{i}$ построенным из std::forward< $T_{i}$ >( $t_{i}$ ),
(1.7)
$U_{j}$ - $j^{th}$ выведенный тип UnBoundArgs&&... параметра оболочки переадресации вызовов, а
(1.8)
$u_{j}$ это $j^{th}$ аргумент , связанный с $U_{j}$ .

template<class F, class... BoundArgs> unspecified bind(F&& f, BoundArgs&&... bound_args);

Requires: is_constructible_v<FD, F> будет true. Для каждого $T_{i}$ в BoundArgs, is_constructible_v< ${TD}_{i}$ , $T_{i}$ > должно быть true. INVOKE(fd, $w_{1}$ , $w_{2}$ , …, $w_{N}$ ) ([func.require]) Должен быть допустимым выражением для некоторых значений $w_{1}$ , $w_{2}$ , ..., $w_{N}$ , где N имеет значение sizeof...(bound_args). Квалификаторы cv cv оболочки вызова g, как указано ниже, не должны быть ни, volatile ни const volatile.

Returns: forwarding call wrapper g. Эффект g( $u_{1}$ , $u_{2}$ , …, $u_{M}$ ) должен быть

INVOKE(fd, std::forward< $V_{1}$ >( $v_{1}$ ), std::forward< $V_{2}$ >( $v_{2}$ ), …, std::forward< $V_{N}$ >( $v_{N}$ ))

где значения и типы связанных аргументов $v_{1}$ , $v_{2}$ ..., $v_{N}$ определяются , как указано ниже. Конструктор копирования и конструктор перемещения оболочки перенаправляющего вызова должны вызывать исключение тогда и только тогда, когда соответствующий конструктор FD любого из типов ${TD}_{i}$ вызывает исключение.

Throws: Ничего, если конструкция fd или одно из значений не ${td}_{i}$ вызывает исключение.

Remarks: Тип возвращаемого значения должен удовлетворять требованиям MoveConstructible. Если все FD и ${TD}_{i}$ удовлетворяют требованиям CopyConstructible, то тип возвращаемого значения должен удовлетворять требованиям CopyConstructible. [ Note: Это подразумевает, что все так FD и ${TD}_{i}$ есть MoveConstructible. ] — end note

template<class R, class F, class... BoundArgs> unspecified bind(F&& f, BoundArgs&&... bound_args);

Requires: is_constructible_v<FD, F> будет true. Для каждого $T_{i}$ в BoundArgs, is_constructible_v< ${TD}_{i}$ , $T_{i}$ > должно быть true. INVOKE(fd, $w_{1}$ , $w_{2}$ , …, $w_{N}$ ) должен быть допустимым выражением для некоторых значений $w_{1}$ , $w_{2}$ , ..., $w_{N}$ , где N имеет значение sizeof...(bound_args). Квалификаторы cv cv оболочки вызова g, как указано ниже, не должны быть ни, volatile ни const volatile.

Returns: forwarding call wrapper g. Эффект g( $u_{1}$ , $u_{2}$ , …, $u_{M}$ ) должен быть

INVOKE<R>(fd, std::forward< $V_{1}$ >( $v_{1}$ ), std::forward< $V_{2}$ >( $v_{2}$ ), …, std::forward< $V_{N}$ >( $v_{N}$ ))

Throws: Ничего, если конструкция fd или одно из значений не ${td}_{i}$ вызывает исключение.

Эти значения bound arguments $v_{1}$ , $v_{2}$ , ..., $v_{N}$ и соответствующие их типы $V_{1}$ , $V_{2}$ , ..., в $V_{N}$ зависимости от типов , ${TD}_{i}$ полученных от вызова bind и CV-классификаторов cv обертки вызова g следующим образом :

(10.1)
если ${TD}_{i}$ есть reference_wrapper<T>, аргумент равен ${td}_{i}$ .get() и его тип $V_{i}$ равен T&;
(10.2)
если значение is_bind_expression_v< ${TD}_{i}$ > равно true, аргумент равен ${td}_{i}$ (std::forward< $U_{j}$ >( $u_{j}$ )...) и его тип $V_{i}$ равен invoke_result_t< ${TD}_{i}$ cv &, $U_{j}$ ...>&&;
(10.3)
если значение j в is_placeholder_v< ${TD}_{i}$ > не равен нулю, аргумент std::forward< $U_{j}$ >( $u_{j}$ ) и ее тип $V_{i}$ является $U_{j}$ &&;
(10.4)
в противном случае значение равно, ${td}_{i}$ а его тип $V_{i}$ - ${TD}_{i}$ cv &.

23.14.11.4 Placeholders [func.bind.place]

namespace std::placeholders {
  // M is the implementation-defined number of placeholders
  see below _1;
  see below _2;
              .
              .
              .
  see below _M;
}

Все типы заполнителей должны быть DefaultConstructible и CopyConstructible, а их конструкторы по умолчанию и конструкторы копирования / перемещения не должны вызывать исключений. Это определяется реализацией ли типы заполнителей являются CopyAssignable. CopyAssignable Операторы присваивания копий заполнителей не должны вызывать исключений.

Заполнители следует определять как:

inline constexpr unspecified _1{};

Если это не так, они должны быть объявлены как:

extern unspecified _1;

23.14.12 Function template mem_fn [func.memfn]

template<class R, class T> unspecified mem_fn(R T::* pm) noexcept;

Returns: Простой call wrapper fn такой, что выражение fn(t, a2, ..., aN) эквивалентно INVOKE(pm, t, a2, ..., aN) ([func.require]).

23.14.13 Polymorphic function wrappers [func.wrap]

В этом подпункте описывается полиморфный класс-оболочка, который инкапсулирует произвольные вызываемые объекты.

23.14.13.1 Class bad_function_call [func.wrap.badcall]

Исключение типа bad_function_call выдается функциейfunction::operator() ([func.wrap.func.inv]), когда объект-оболочка функции не имеет цели.

namespace std {
  class bad_function_call : public exception {
  public:
    // [func.wrap.badcall.const], constructor
    bad_function_call() noexcept;
  };
}

23.14.13.1.1 bad_function_call constructor [func.wrap.badcall.const]

bad_function_call() noexcept;

Effects: Создает bad_function_call объект.

Postconditions: what() возвращает определяемый реализацией файл ntbs .

23.14.13.2 Class template function [func.wrap.func]

namespace std {
  template<class> class function; // not defined

  template<class R, class... ArgTypes>
  class function<R(ArgTypes...)> {
  public:
    using result_type = R;

    // [func.wrap.func.con], construct/copy/destroy
    function() noexcept;
    function(nullptr_t) noexcept;
    function(const function&);
    function(function&&);
    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();

    // [func.wrap.func.mod], function modifiers
    void swap(function&) noexcept;

    // [func.wrap.func.cap], function capacity
    explicit operator bool() const noexcept;

    // [func.wrap.func.inv], function invocation
    R operator()(ArgTypes...) const;

    // [func.wrap.func.targ], 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 below>;

  // [func.wrap.func.nullptr], Null pointer comparisons
  template <class R, class... ArgTypes>
    bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;

  template <class R, class... ArgTypes>
    bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;

  template <class R, class... ArgTypes>
    bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;

  template <class R, class... ArgTypes>
    bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;

  // [func.wrap.func.alg], specialized algorithms
  template <class R, class... ArgTypes>
    void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
}

function Шаблон класса обеспечивает полиморфные упаковщики, обобщающие понятие указателя функции. Оболочки могут хранить, копировать и вызывать произвольные callable objects, заданные a call signature, что позволяет функциям быть первоклассными объектами.

A callable type F используется Lvalue-Callable для типов аргументов ArgTypes и типа возвращаемого значения, R если выражение INVOKE<R>(declval<F&>(), declval<ArgTypes>()...), рассматриваемое как a unevaluated operand, имеет правильный формат ([func.require]).

function Шаблон класса является call wrapper которого call signature является R(ArgTypes...).

[ Note: Типы, определенные в руководствах по вычетам, function могут измениться в будущих версиях этого международного стандарта. ] — end note

23.14.13.2.1 function construct/copy/destroy [func.wrap.func.con]

function() noexcept;

Postconditions: !*this.

function(nullptr_t) noexcept;

Postconditions: !*this.

function(const function& f);

Postconditions: !*this если !f; в противном случае *this нацелена на копию f.target().

Throws: не должен генерировать исключения, если fцель является специализацией reference_wrapper или указателем на функцию. В противном случае может вызвать bad_alloc или любое исключение, созданное конструктором копирования сохраненного вызываемого объекта. [ Note: Реализациям рекомендуется избегать использования динамически выделяемой памяти для небольших вызываемых объектов, например, где fцелью является объект, содержащий только указатель или ссылку на объект и указатель на функцию-член. ] — end note

function(function&& f);

Postconditions: Если !f, *this не имеют целей; в противном случае цель *this эквивалентна цели f до построения и f находится в допустимом состоянии с неопределенным значением.

Throws: не должен генерировать исключения, если fцель является специализацией reference_wrapper или указателем на функцию. В противном случае может вызвать bad_alloc или любое исключение, созданное конструктором копирования или перемещения сохраненного вызываемого объекта. [ Note: Реализациям рекомендуется избегать использования динамически выделяемой памяти для небольших вызываемых объектов, например, где fцелью является объект, содержащий только указатель или ссылку на объект и указатель на функцию-член. ] — end note

template<class F> function(F f);

Requires: F будет CopyConstructible.

Remarks: Этот шаблон конструктора не должен участвовать в разрешении перегрузки, если только он не F предназначен Lvalue-Callable для типов аргументов ArgTypes... и типа возвращаемого значения R.

Postconditions: !*this если выполняется какое-либо из следующих условий:

(9.1)
f - значение указателя нулевой функции.
(9.2)
f - значение указателя на нулевой член.
(9.3)
F является экземпляром function шаблона класса, а !f.

В противном случае *this нацелена на копию, f инициализированную с помощью std::move(f). [ Note: Реализациям рекомендуется избегать использования динамически выделяемой памяти для небольших вызываемых объектов, например, где f объект, содержащий только указатель или ссылку на объект и указатель на функцию-член. ] — end note

Throws: не должен генерировать исключения, если f это указатель на функцию или reference_wrapper<T> для некоторых T. В противном случае может вызвать bad_alloc или любое исключение, созданное конструктором Fкопирования или перемещения.

template<class F> function(F) -> function<see below>;

Remarks: Это руководство по выводу участвует в разрешении перегрузки только в том случае, если &F::operator() оно правильно сформировано, когда рассматривается как неоцененный операнд. В том случае, если decltype(&F::operator()) is имеет форму R(G::*)(A...) cv & $_{o p t}$ noexcept $_{o p t}$ для типа класса G, то выводимый тип имеет вид function<R(A...)>.

[ Example:

void f() {
  int i{5};
  function g = [&](double) { return i; }; // deduces function<int(double)>
}

— end example ]

function& operator=(const function& f);

Effects: Как если бы function(f).swap(*this);

Returns: *this.

function& operator=(function&& f);

Effects: Заменяет цель *this на цель f.

Returns: *this.

function& operator=(nullptr_t) noexcept;

Effects: Если *this != nullptr, уничтожает цель this.

Postconditions: !(*this).

Returns: *this.

template<class F> function& operator=(F&& f);

Effects: Как будто по: function(std::forward<F>(f)).swap(*this);

Returns: *this.

Remarks: Этот оператор присваивания не должен участвовать в разрешении перегрузки, кроме decay_t<F> как Lvalue-Callable для типов аргументов ArgTypes... и типа возвращаемого значения R.

template<class F> function& operator=(reference_wrapper<F> f) noexcept;

Effects: Как будто по: function(f).swap(*this);

Returns: *this.

~function();

Effects: Если *this != nullptr, уничтожает цель this.

23.14.13.2.2 function modifiers [func.wrap.func.mod]

void swap(function& other) noexcept;

Effects: меняет местами цели *this и other.

23.14.13.2.3 function capacity [func.wrap.func.cap]

explicit operator bool() const noexcept;

Returns: true если *this есть цель, иначе false.

23.14.13.2.4 function invocation [func.wrap.func.inv]

R operator()(ArgTypes... args) const;

Returns: INVOKE<R>(f, std::forward<ArgTypes>(args)...) ([func.require]), где f - target object оф *this.

Throws: bad_function_call если !*this; в противном случае - любое исключение, созданное обернутым вызываемым объектом.

23.14.13.2.5 function target access [func.wrap.func.targ]

const type_info& target_type() const noexcept;

Returns: Если *this есть цель типа T, typeid(T); в противном случае typeid(void).

template<class T> T* target() noexcept; template<class T> const T* target() const noexcept;

Returns: Если target_type() == typeid(T) указатель на сохраненную функцию target; в противном случае - нулевой указатель.

23.14.13.2.6 null pointer comparison functions [func.wrap.func.nullptr]

template <class R, class... ArgTypes> bool operator==(const function<R(ArgTypes...)>& f, nullptr_t) noexcept; template <class R, class... ArgTypes> bool operator==(nullptr_t, const function<R(ArgTypes...)>& f) noexcept;

Returns: !f.

template <class R, class... ArgTypes> bool operator!=(const function<R(ArgTypes...)>& f, nullptr_t) noexcept; template <class R, class... ArgTypes> bool operator!=(nullptr_t, const function<R(ArgTypes...)>& f) noexcept;

Returns: (bool)f.

23.14.13.2.7 specialized algorithms [func.wrap.func.alg]

template<class R, class... ArgTypes> void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>& f2) noexcept;

Effects: Как будто по: f1.swap(f2);

23.14.14 Searchers [func.search]

В этом подпункте предусмотрены function object types операции, которые ищут последовательность [pat_first, pat_last) в другой последовательности, [first, last) которая предоставляется оператору вызова функции объекта. Первая последовательность (шаблон для поиска) предоставляется конструктору объекта, а вторая (последовательность для поиска) предоставляется оператору вызова функции.

Каждая специализация шаблона класса , указанного в настоящем подпункте , [func.search] должны отвечать CopyConstructible и CopyAssignable требованиям. Параметры шаблона с именем

(2.1)
ForwardIterator,
(2.2)
ForwardIterator1,
(2.3)
ForwardIterator2,
(2.4)
RandomAccessIterator,
(2.5)
RandomAccessIterator1,
(2.6)
RandomAccessIterator2, а также
(2.7)
BinaryPredicate

шаблонов, указанных в этом подпункте, [func.search] должны соответствовать тем же требованиям и семантике, что и в [algorithms.general]. Названные параметры шаблона Hash должны соответствовать требованиям, указанным в [hash.requirements].

Программа поиска Бойера-Мура реализует алгоритм поиска Бойера-Мура. Программа поиска Boyer-Moore-Horspool реализует алгоритм поиска Boyer-Moore-Horspool. В общем, поисковик Бойера-Мура будет использовать больше памяти и работать лучше, чем Бойер-Мур-Хорспул.

23.14.14.1 Class template default_searcher [func.search.default]

template <class ForwardIterator1, class BinaryPredicate = equal_to<>>
  class default_searcher {
  public:
    default_searcher(ForwardIterator1 pat_first, ForwardIterator1 pat_last,
                     BinaryPredicate pred = BinaryPredicate());

    template <class ForwardIterator2>
      pair<ForwardIterator2, ForwardIterator2>
        operator()(ForwardIterator2 first, ForwardIterator2 last) const;

  private:
    ForwardIterator1 pat_first_;        // exposition only
    ForwardIterator1 pat_last_;         // exposition only
    BinaryPredicate pred_;              // exposition only
  };

default_searcher(ForwardIterator pat_first, ForwardIterator pat_last, BinaryPredicate pred = BinaryPredicate());

Effects: Создает default_searcher объект, инициализируясь pat_first_ с помощью pat_first, pat_last_с помощью pat_lastи pred_ с помощью pred.

Throws: Любое исключение, созданное конструктором копирования BinaryPredicate или ForwardIterator1.

template<class ForwardIterator2> pair<ForwardIterator2, ForwardIterator2> operator()(ForwardIterator2 first, ForwardIterator2 last) const;

Effects: Возвращает пару итераторов i и j таких, что

(3.1)
i == search(first, last, pat_first_, pat_last_, pred_), а также
(3.2)
если i == last, то j == lastиначе j == next(i, distance(pat_first_, pat_last_)).

23.14.14.2 Class template boyer_moore_searcher [func.search.bm]

template <class RandomAccessIterator1,
          class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
          class BinaryPredicate = equal_to<>>
  class boyer_moore_searcher {
  public:
    boyer_moore_searcher(RandomAccessIterator1 pat_first,
                         RandomAccessIterator1 pat_last,
                         Hash hf = Hash(),
                         BinaryPredicate pred = BinaryPredicate());

    template <class RandomAccessIterator2>
      pair<RandomAccessIterator2, RandomAccessIterator2>
        operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;

  private:
    RandomAccessIterator1 pat_first_;   // exposition only
    RandomAccessIterator1 pat_last_;    // exposition only
    Hash hash_;                         // exposition only
    BinaryPredicate pred_;              // exposition only
  };

boyer_moore_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last, Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());

Requires: Тип значения RandomAccessIterator1 должен соответствовать DefaultConstructible требованиям, CopyConstructible требованиям и CopyAssignable требованиям.

Requires: Для любых двух значений A и B типа iterator_traits<RandomAccessIterator1>::value_type, если pred(A, B) == true, то hf(A) == hf(B) должно быть true.

Effects: Создает boyer_moore_searcher объект, инициализируясь pat_first_ с pat_first, pat_last_ с pat_last, hash_ с hfи pred_ с pred.

Throws: Любое исключение брошенная копию конструктора RandomAccessIterator1, или с помощью конструктора по умолчанию, конструктор копирования или оператор присваивания копии типа ценностной RandomAccessIterator1или конструктор копирования или operator() из BinaryPredicate или Hash. Может bad_alloc вызвать ошибку, если не может быть выделена дополнительная память, необходимая для внутренних структур данных.

template <class RandomAccessIterator2> pair<RandomAccessIterator2, RandomAccessIterator2> operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;

Requires: RandomAccessIterator1 и RandomAccessIterator2 должен иметь один и тот же тип значения.

Effects: Находит подпоследовательность равных значений в последовательности.

Returns: Пара итераторов i и j такие, что

(7.1)
i - это первый итератор в диапазоне, [first, last - (pat_last_ - pat_first_)) такой, что для каждого неотрицательного целого числа, n меньшего, чем pat_last_ - pat_first_ выполняется следующее условие:, pred(*(i + n), *(pat_first_ + n)) != falseи
(7.2)
j == next(i, distance(pat_first_, pat_last_)).

Возвращает, make_pair(first, first) если [pat_first_, pat_last_) пусто, в противном случае возвращает, make_pair(last, last) если такой итератор не найден.

Complexity: В большинстве (last - first) * (pat_last_ - pat_first_) случаев применения предиката.

23.14.14.3 Class template boyer_moore_horspool_searcher [func.search.bmh]

template <class RandomAccessIterator1,
          class Hash = hash<typename iterator_traits<RandomAccessIterator1>::value_type>,
          class BinaryPredicate = equal_to<>>
  class boyer_moore_horspool_searcher {
  public:
    boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first,
                                  RandomAccessIterator1 pat_last,
                                  Hash hf = Hash(),
                                  BinaryPredicate pred = BinaryPredicate());

    template <class RandomAccessIterator2>
      pair<RandomAccessIterator2, RandomAccessIterator2>
        operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;

  private:
    RandomAccessIterator1 pat_first_;   // exposition only
    RandomAccessIterator1 pat_last_;    // exposition only
    Hash hash_;                         // exposition only
    BinaryPredicate pred_;              // exposition only
  };

boyer_moore_horspool_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last, Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());

Requires: Тип значения RandomAccessIterator1 должны удовлетворять DefaultConstructible, CopyConstructibleи CopyAssignable требования.

Requires: Для любых двух значений A и B типа iterator_traits<RandomAccessIterator1>::value_type, если pred(A, B) == true, то hf(A) == hf(B) должно быть true.

Effects: Создает boyer_moore_horspool_searcher объект, инициализируясь pat_first_ с pat_first, pat_last_ с pat_last, hash_ с hfи pred_ с pred.

Throws: Любое исключение брошенная копию конструктора RandomAccessIterator1, или с помощью конструктора по умолчанию, конструктор копирования или оператор присваивания копии типа ценностной RandomAccessIterator1 или копирующего конструктора или operator() из BinaryPredicate или Hash. Может bad_alloc вызвать ошибку, если не может быть выделена дополнительная память, необходимая для внутренних структур данных.

template <class RandomAccessIterator2> pair<RandomAccessIterator2, RandomAccessIterator2> operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;

Requires: RandomAccessIterator1 и RandomAccessIterator2 должен иметь один и тот же тип значения.

Effects: Находит подпоследовательность равных значений в последовательности.

Returns: Пара итераторов i и j такие, что

(7.1)
i - это первый итератор i в диапазоне, [first, last - (pat_last_ - pat_first_)) такой, что для каждого неотрицательного целого числа, n меньшего, чем pat_last_ - pat_first_ выполняется следующее условие:, pred(*(i + n), *(pat_first_ + n)) != falseи
(7.2)
j == next(i, distance(pat_first_, pat_last_)).

Complexity: В большинстве (last - first) * (pat_last_ - pat_first_) случаев применения предиката.

23.14.15 Class template hash [unord.hash]

Неупорядоченные ассоциативные контейнеры, определенные в [unord] специализациях класса template hash ([functional.syn]) в качестве хэш-функции по умолчанию.

Каждая специализация hash включена или отключена, как описано ниже. [ Note: Включенные специализации соответствуют требованиям Hash, а отключенные - нет. ] Каждый заголовок, который объявляет шаблон, предоставляет включенные специализации для и всех cv-неквалифицированных типов арифметики, перечисления и указателя. Для любого типа, для которого ни библиотека, ни пользователь не предоставляют явную или частичную специализацию шаблона класса , отключен. — end note hash hash nullptr_t Key hashhash<Key>

Если библиотека предоставляет явную или частичную специализацию hash<Key>, эта специализация включена, если не указано иное, и ее функции-члены, noexcept если не указано иное.

Если H инвалид специализации hash, эти значения false: is_default_constructible_v<H>, is_copy_constructible_v<H>, is_move_constructible_v<H>, is_copy_assignable_v<H>, и is_move_assignable_v<H>. Инвалидов специализации hash нет function object types. [ Note: Это означает, что специализация hash существует, но любые попытки использовать ее как a Hash будут плохо сформированы. ] — end note

Включенная специализация hash<Key> :

(5.1)
удовлетворяют Hash requirements, с Key как тип аргумента вызова функции, то DefaultConstructible requirements, то CopyAssignable requirements,
(5.2)
быть swappable для lvalues,
(5.3)
удовлетворяют требованию, что if k1 == k2 is true, h(k1) == h(k2) is также true, where h is объект типа hash<Key> и k1 and k2 are объекты типа Key;
(5.4)
удовлетворять требованию, согласно которому выражение h(k), где h является объектом типа hash<Key> и k является объектом типа Key, не должно вызывать исключения, если только hash<Key> это не определенная пользователем специализация, которая зависит по крайней мере от одного определяемого пользователем типа.

23 General utilities library [utilities]

23.14 Function objects [function.objects]

23.14.1 Header <functional> synopsis [functional.syn]

23.14.2 Definitions [func.def]

23.14.3 Requirements [func.require]

23.14.4 Function template invoke [func.invoke]

23.14.5 Class template reference_­wrapper [refwrap]

23.14.5.1 reference_­wrapper construct/copy/destroy [refwrap.const]

23.14.5.2 reference_­wrapper assignment [refwrap.assign]

23.14.5.3 reference_­wrapper access [refwrap.access]

23.14.5.4 reference_­wrapper invocation [refwrap.invoke]

23.14.5.5 reference_­wrapper helper functions [refwrap.helpers]

23.14.6 Arithmetic operations [arithmetic.operations]

23.14.6.1 Class template plus [arithmetic.operations.plus]

23.14.6.2 Class template minus [arithmetic.operations.minus]

23.14.6.3 Class template multiplies [arithmetic.operations.multiplies]

23.14.6.4 Class template divides [arithmetic.operations.divides]

23.14.6.5 Class template modulus [arithmetic.operations.modulus]

23.14.6.6 Class template negate [arithmetic.operations.negate]

23.14.7 Comparisons [comparisons]

23.14.7.1 Class template equal_­to [comparisons.equal_to]

23.14.7.2 Class template not_­equal_­to [comparisons.not_equal_to]

23.14.7.3 Class template greater [comparisons.greater]

23.14.7.4 Class template less [comparisons.less]

23.14.7.5 Class template greater_­equal [comparisons.greater_equal]

23.14.7.6 Class template less_­equal [comparisons.less_equal]

23.14.8 Logical operations [logical.operations]

23.14.8.1 Class template logical_­and [logical.operations.and]

23.14.8.2 Class template logical_­or [logical.operations.or]

23.14.8.3 Class template logical_­not [logical.operations.not]

23.14.9 Bitwise operations [bitwise.operations]

23.14.9.1 Class template bit_­and [bitwise.operations.and]

23.14.9.2 Class template bit_­or [bitwise.operations.or]

23.14.9.3 Class template bit_­xor [bitwise.operations.xor]

23.14.9.4 Class template bit_­not [bitwise.operations.not]

23.14.10 Function template not_­fn [func.not_fn]

23.14.11 Function object binders [func.bind]

23.14.11.1 Class template is_­bind_­expression [func.bind.isbind]

23.14.11.2 Class template is_­placeholder [func.bind.isplace]

23.14.11.3 Function template bind [func.bind.bind]

23.14.11.4 Placeholders [func.bind.place]

23.14.12 Function template mem_­fn [func.memfn]

23.14.13 Polymorphic function wrappers [func.wrap]

23.14.13.1 Class bad_­function_­call [func.wrap.badcall]

23.14.13.1.1 bad_­function_­call constructor [func.wrap.badcall.const]

23.14.13.2 Class template function [func.wrap.func]

23.14.13.2.1 function construct/copy/destroy [func.wrap.func.con]

23.14.13.2.2 function modifiers [func.wrap.func.mod]

23.14.13.2.3 function capacity [func.wrap.func.cap]

23.14.13.2.4 function invocation [func.wrap.func.inv]

23.14.13.2.5 function target access [func.wrap.func.targ]

23.14.13.2.6 null pointer comparison functions [func.wrap.func.nullptr]

23.14.13.2.7 specialized algorithms [func.wrap.func.alg]

23.14.14 Searchers [func.search]

23.14.14.1 Class template default_­searcher [func.search.default]

23.14.14.2 Class template boyer_­moore_­searcher [func.search.bm]

23.14.14.3 Class template boyer_­moore_­horspool_­searcher [func.search.bmh]

23.14.15 Class template hash [unord.hash]

23.14.5 Class template reference_wrapper [refwrap]

23.14.5.1 reference_wrapper construct/copy/destroy [refwrap.const]

23.14.5.2 reference_wrapper assignment [refwrap.assign]

23.14.5.3 reference_wrapper access [refwrap.access]

23.14.5.4 reference_wrapper invocation [refwrap.invoke]

23.14.5.5 reference_wrapper helper functions [refwrap.helpers]

23.14.7.1 Class template equal_to [comparisons.equal_to]

23.14.7.2 Class template not_equal_to [comparisons.not_equal_to]

23.14.7.5 Class template greater_equal [comparisons.greater_equal]

23.14.7.6 Class template less_equal [comparisons.less_equal]

23.14.8.1 Class template logical_and [logical.operations.and]

23.14.8.2 Class template logical_or [logical.operations.or]

23.14.8.3 Class template logical_not [logical.operations.not]

23.14.9.1 Class template bit_and [bitwise.operations.and]

23.14.9.2 Class template bit_or [bitwise.operations.or]

23.14.9.3 Class template bit_xor [bitwise.operations.xor]

23.14.9.4 Class template bit_not [bitwise.operations.not]

23.14.10 Function template not_fn [func.not_fn]

23.14.11.1 Class template is_bind_expression [func.bind.isbind]

23.14.11.2 Class template is_placeholder [func.bind.isplace]

23.14.12 Function template mem_fn [func.memfn]

23.14.13.1 Class bad_function_call [func.wrap.badcall]

23.14.13.1.1 bad_function_call constructor [func.wrap.badcall.const]

23.14.14.1 Class template default_searcher [func.search.default]

23.14.14.2 Class template boyer_moore_searcher [func.search.bm]

23.14.14.3 Class template boyer_moore_horspool_searcher [func.search.bmh]