Заголовочный файл стандартной библиотеки <functional>

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов (C++20)

Библиотека метапрограммирования (C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов (C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения (C++11)

Атомарные операции (C++11)

Библиотека поддержки конкуренции (C++11)

Библиотека файловой системы (C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Заголовочные файлы стандартной библиотеки

Языковая поддержка
<cstddef> <cstdlib> <version> (C++20) <limits> <climits>	<cfloat> <cstdint> (C++11) <stdfloat> (C++23) <new> <typeinfo>	<source_location> (C++20) <exception> <initializer_list> (C++11) <compare> (C++20)	<coroutine> (C++20) <csignal> <csetjmp> <cstdarg>
Концепты
<concepts> (C++20)
Диагностика
<stdexcept> <stacktrace> (C++23)	<cassert>	<cerrno>	<system_error> (C++11)
Управление памятью
<memory>	<memory_resource> (C++17)	<scoped_allocator> (C++11)
Метапрограммирование
<type_traits> (C++11)	<ratio> (C++11)
Общие утилиты
<utility> <tuple> (C++11) <optional> (C++17) <variant> (C++17)	<any> (C++17) <expected> (C++23) <bitset>	<functional> <typeindex> (C++11) <execution> (C++17)	<charconv> (C++17) <format> (C++20) <bit> (C++20)
Строки
<string_view> (C++17) <string>	<cctype> <cwctype>	<cstring> <cwchar>	<cuchar> (C++11)
Контейнеры
<array> (C++11) <deque> <forward_list> (C++11) <list>	<vector> <map> <set> <unordered_map> (C++11)	<unordered_set> (C++11) <queue> <stack> <flat_map> (C++23)	<flat_set> (C++23) <span> (C++20) <mdspan> (C++23)
Итераторы
<iterator>
Диапазоны
<ranges> (C++20)	<generator> (C++23)
Алгоритмы
<algorithm>	<numeric>
Числа
<cfenv> (C++11) <complex>	<random> (C++11) <valarray>	<cmath>	<numbers> (C++20)
Время
<chrono> (C++11)	<ctime>
Локализация
<locale>	<clocale>	<codecvt> (C++11/17*)
Ввод/вывод
<iosfwd> <iostream> <ios> <streambuf>	<istream> <ostream> <iomanip> <print> (C++23)	<sstream> <spanstream> (C++23) <fstream> <syncstream> (C++20)	<filesystem> (C++17) <cstdio> <cinttypes> (C++11) <strstream> (C++98*)
Регулярные выражения
<regex> (C++11)
Поддержка конкуренции
<stop_token> (C++20) <thread> (C++11) <atomic> (C++11)	<stdatomic.h> (C++23) <mutex> (C++11) <shared_mutex> (C++14)	<condition_variable> (C++11)   <semaphore> (C++20) <latch> (C++20)	<barrier> (C++20) <future> (C++11)
Совместимость с C
<cstdbool> (C++11/17/20*)   <ccomplex> (C++11/17/20*)	<ctgmath> (C++11/17/20*)	<cstdalign> (C++11/17/20*)	<ciso646> (до C++20)

 

Этот заголовок является частью библиотеки объекты функций и предоставляет стандартную хеш-функцию.

Пространства имён
placeholders (C++11)	Предоставляет заполнители для несвязанных аргументов в выражении std::bind
Классы
Обёртки
function (C++11)	обёртывает вызываемый объект любого конструируемого копированием типа с указанной сигнатурой вызова функции (шаблон класса)
move_only_function (C++23)	обёртывает вызываемый объект любого типа с указанной сигнатурой вызова функции (шаблон класса)
copyable_function (C++26)	уточнение std::move_only_function, которое обертывает вызываемый объект любого конструируемого копированием типа (шаблон класса)
function_ref (C++26)	невладеющая ссылка на любой вызываемый объект с указанной сигнатурой вызова функции (шаблон класса)
mem_fn (C++11)	создаёт объект функцию из указателя на элемент (шаблон функции)
reference_wrapper (C++11)	обёртка ссылок CopyConstructible и CopyAssignable (шаблон класса)
unwrap_referenceunwrap_ref_decay (C++20)(C++20)	получает ссылочный тип, заключённый в std::reference_wrapper (шаблон класса)
Вспомогательные классы
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_horspool_searcher (C++17)	реализация алгоритма поиска Бойера-Мура-Хорспула (шаблон класса)
Хеширование
hash (C++11)	Объект хеш-функции (шаблон класса)
std::hash<Арифметика>std::hash<Перечисление>std::hash<std::nullptr_t>std::hash<T*> (C++11)	std::hash специализации для основных типов, типов перечислений и указателей (специализация шаблона класса)
Константы
Определены в пространстве имён std::placeholders
_1, _2, _3, _4, ... (C++11)	заполнители для несвязанных аргументов в выражении std::bind (константа)
Функции
bind_frontbind_back (C++20)(C++23)	связывает переменное количество аргументов по порядку с объектом функцией (шаблон функции)
bind (C++11)	связывает один или несколько аргументов с объектом функцией (шаблон функции)
refcref (C++11)(C++11)	создаёт std::reference_wrapper с типом, выведенным из его аргумента (шаблон функции)
invokeinvoke_r (C++17)(C++23)	вызывает любой Callable объект с данными аргументами и имеет возможность указать тип возврата (начиная с C++23) (шаблон функции)

Устарело в C++11 и удалено в C++17

Базовые
unary_function (устарело в C++11)(удалено в C++17)	совместимый с адаптором базовый класс унарной функции (шаблон класса)
binary_function (deprecated in C++11)(удалено в C++17)	совместимый с адаптером базовый класс бинарной функции (шаблон класса)
Связующие
binder1stbinder2nd (устарело в C++11)(удалено в C++17)	объект функции, содержащий бинарную функцию и один из её аргументов (шаблон класса)
bind1stbind2nd (устарело в 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_tmem_fun1_tconst_mem_fun_tconst_mem_fun1_t (устарело в C++11)(удалено в C++17)	оболочка для указателя на нульарную или унарную функцию-элемент, вызываемую с указателем на объект (шаблон класса)
mem_fun (устарело в C++11)(удалено в C++17)	создаёт оболочку из указателя на функцию-элемент, вызываемую через указатель на объект (шаблон функции)
mem_fun_ref_tmem_fun1_ref_tconst_mem_fun_ref_tconst_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 (deprecated in 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>;

  // идентичность
  struct identity;

  // шаблонная функция not_fn
  template<class F> constexpr /* неопределено */ not_fn(F&& f);

  // шаблонные функции bind_front и bind_back
  template<class F, class... Args> constexpr /* неопределено */ bind_front(F&&, Args&&...);
  template<class F, class... Args> constexpr /* неопределено */ bind_back(F&&, Args&&...);

  // привязка
  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; // не определено
  template<class R, class... ArgTypes> class function<R(ArgTypes...)>;

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

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

  template<class...> class move_only_function; // не определено

  template<class R, class... ArgTypes>
    class move_only_function<R(ArgTypes...) /*cv ref*/ noexcept(/*noex*/)>;

  // искатели
  template<class 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();

    // функции модификаторы
    void swap(function&) noexcept;

    // функция ёмкости
    explicit operator bool() const noexcept;

    // функция вызова
    R operator()(ArgTypes...) const;

    // функция доступа к цели
    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</* смотрите описание */>;

  // функции сравнения нулевого указателя
  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 /*можно-вызвать-из*/ = /* смотрите описание */;
  };
}

Шаблонный класс 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::hash для std::string, std::u16string, std::u32string, std::wstring
<string_view>	Специализации std::hash для std::string_view, std::u16string_view, std::u32string_view, std::wstring_view
<system_error>	Специализации std::hash для std::error_code
<bitset>	Специализации std::hash для std::bitset
<memory>	Специализации std::hash для std::unique_ptr, std::shared_ptr
<typeindex>	Специализации std::hash для std::type_index
<vector>	Специализации std::hash для std::vector<bool>
<thread>	Специализации std::hash для std::thread::id
<optional>	Специализации std::hash для std::optional
<variant>	Специализации std::hash для std::variant
<coroutine>	Специализации std::hash для std::coroutine_handle
<stacktrace>	Специализации std::hash для std::stacktrace_entry and std::basic_stacktrace