Archivo de encabezado de la biblioteca estándar <functional>

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Archivos de encabezado de la biblioteca estándar

Apoyo del lenguaje <cfloat> <climits> <compare> (C++20) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) Conceptos <concepts> (C++20) Diagnósticos <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) Gestión de memoria <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) Metaprogramación <type_traits> (C++11) <ratio> (C++11)

Servicios generales <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) Contenedores <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> Iteradores <iterator> Rangos <generator> (C++23) <ranges> (C++20)

Algoritmos <algorithm> <numeric> Cadenas <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> Procesamiento de texto <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    Numéricos <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <valarray> Tiempo <chrono> (C++11) <ctime> Compatibilidad con C <ccomplex> (C++11/17/20*) <ciso646> (hasta C++20) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

Entrada/Salida <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) Apoyo para concurrencia <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) Apoyo de ejecución <execution> (C++17)

 

See More

Este archivo de encabezado es parte de la biblioteca de objetos función y proporciona la función estándar hash.

Espacios de nombres

placeholders	Define marcadores de posición para los argumentos no vinculados en una expresión std::bind.
Constantes
Definido en el espacio de nombres std::placeholders
_1, _2, _3, _4, ... (C++11)	Marcadores de posición para los argumentos no vinculados en una expresión std::bind. (constante)

Clases

function (C++11)	Envuelve un objeto que puede ser llamado a cualquier tipo con la signatura de llamada a función especificada. (plantilla de clase)
mem_fn (C++11)	Crea un objeto función de un puntero a un miembro. (plantilla de función)
bad_function_call (C++11)	La excepción que se lanza cuando se invoca un objeto std::function vacío. (clase)
is_bind_expression (C++11)	Indica que un objeto es una expresión std::bind o puede usarse como tal. (plantilla de clase)
is_placeholder (C++11)	Indica que un objeto es un marcador de posición estándar o puede usarse como tal. (plantilla de clase)
reference_wrapper (C++11)	Envoltorio de referencia CopyConstructible y CopyAssignable. (plantilla de clase)
Hashing (resumen)
hash (C++11)	Objeto función de dispersión (hash). (plantilla de clase)
template<> struct hash<bool>; template<> struct hash<char>; template<> struct hash<signed char>; template<> struct hash<unsigned char>; template<> struct hash<char16_t>; template<> struct hash<char32_t>; template<> struct hash<wchar_t>; template<> struct hash<short>; template<> struct hash<unsigned short>; template<> struct hash<int>; template<> struct hash<unsigned int>; template<> struct hash<long>; template<> struct hash<long long>; template<> struct hash<unsigned long>; template<> struct hash<unsigned long long>; template<> struct hash<float>; template<> struct hash<double>; template<> struct hash<long double>; template< class T > struct hash<T*>;	std::hash Especializaciones para los tipos integrados (especialización de plantilla de clase)

Funciones

bind (C++11)	Vincula uno o más argumentos a un objeto función. (plantilla de función)
refcref (C++11)(C++11)	Crea un envoltorio de referencia (std::reference_wrapper) con un tipo deducido de su argumento. (plantilla de función)
invokeinvoke_r (C++17)(C++23)	Invoca cualquier objeto Callable con los argumentos dados y la posibilidad de especificar el tipo de retorno. (desde C++23) (plantilla de función)

Objetos función

Operaciones aritméticas
plus	Objeto función que implementa x + y (plantilla de clase)
minus	Objeto función que implementa x - y (plantilla de clase)
multiplies	Objeto función que implementa x * y (plantilla de clase)
divides	Objeto función que implementa x / y. (plantilla de clase)
modulus	Objeto función que implementa x % y (plantilla de clase)
negate	Objeto función que implementa -x (plantilla de clase)
Comparaciones
equal_to	Objeto función que implementa x == y. (plantilla de clase)
not_equal_to	Objeto función que implementa x != y. (plantilla de clase)
greater	Objeto función que implementa x > y. (plantilla de clase)
less	Objeto función que implementa x < y. (plantilla de clase)
greater_equal	Objeto función que implementa x >= y. (plantilla de clase)
less_equal	Objeto función que implementa x <= y (plantilla de clase)
Comparaciones restringidas por conceptos
ranges::equal_to (C++20)	Objeto función que implementa x == y. (clase)
ranges::not_equal_to (C++20)	Objeto función que implementa x != y. (clase)
ranges::greater (C++20)	Objeto función que implementa x > y. (clase)
ranges::less (C++20)	Objeto función que implementa x < y. (clase)
ranges::greater_equal (C++20)	Objeto función que implementa x >= y. (clase)
ranges::less_equal (C++20)	Objeto función que implementa x <= y. (clase)
Operaciones lógicas
logical_and	Objeto función que implementa x && y. (plantilla de clase)
logical_or	Objeto función que implementa x || y. (plantilla de clase)
logical_not	Objeto función que implementa !x. (plantilla de clase)
Operaciones de bits
bit_and	Objeto función que implementa x & y. (plantilla de clase)
bit_or	Objeto función que implementa x | y. (plantilla de clase)
bit_xor	Objeto función que implementa x ^ y. (plantilla de clase)
bit_not (C++14)	Objeto función que implementa ~x. (plantilla de clase)
Negadores
not_fn (C++17)	Crea un objeto función que devuelve el complemento del resultado del objeto función que mantiene. (plantilla de función)
Buscadores
default_searcher (C++17)	Implementación del algoritmo de búsqueda de la biblioteca estándar de C++. (plantilla de clase)
boyer_moore_searcher (C++17)	Implementación del algoritmo de búsqueda Boyer-Moore. (plantilla de clase)
boyer_moore_horspool_searcher (C++17)	Implementación del algoritmo de búsqueda Boyer-Moore-Horspool. (plantilla de clase)

En desuso en C++11 y eliminados en C++17

Base
unary_function (en desuso en C++11)(eliminado en C++17)	Clase base de función unaria compatible con un adaptador. (plantilla de clase)
binary_function (en desuso en C++11)(eliminado en C++17)	Clase base compatible con un adaptador de función binaria. (plantilla de clase)
Vinculadores
binder1stbinder2nd (en desuso en C++11)(eliminado en C++17)	Objeto función que mantiene una función binaria y uno de sus argumentos. (plantilla de clase)
bind1stbind2nd (en desuso en C++11)(eliminado en C++17)	Vincula un argumento a una función binaria. (plantilla de función)
Adaptadores de función
pointer_to_unary_function (en desuso en C++11)(eliminado en C++17)	Envoltorio compatible con un adaptador para un puntero a función unaria. (plantilla de clase)
pointer_to_binary_function (en desuso en C++11)(eliminado en C++17)	Envoltorio compatible con un adaptador para un puntero a función binaria. (plantilla de clase)
ptr_fun (en desuso en C++11)(eliminado en C++17)	Crea un envoltorio de objeto función compatible con un adaptador de un puntero a función (plantilla de función)
mem_fun_tmem_fun1_tconst_mem_fun_tconst_mem_fun1_t (en desuso en C++11)(eliminado en C++17)	Envoltorio para un puntero a una función nularia o función miembro unaria, que puede ser llamado con un puntero a un objeto. (plantilla de clase)
mem_fun (en desuso en C++11)(eliminado en C++17)	Crea un envoltorio de un puntero a función miembro, que puede ser llamado con un puntero a un objeto. (plantilla de función)
mem_fun_ref_tmem_fun1_ref_tconst_mem_fun_ref_tconst_mem_fun1_ref_t (en desuso en C++11)(eliminado en C++17)	Envoltorio para un puntero a una función nularia o función miembro unaria, que puede ser llamado con una referencia a un objeto. (plantilla de clase)
mem_fun_ref (en desuso en C++11)(eliminado en C++17)	Crea un envoltorio de un puntero a función miembro, que puede ser llamado con una referencia a un objeto. (plantilla de función)

En desuso en C++17 y eliminados en C++20

Negadores
unary_negate (en desuso en C++17)(eliminado en C++20)	Envoltorio de objeto función que devuelve el complemento del predicado unario que mantiene. (plantilla de clase)
binary_negate (en desuso en C++17)(eliminado en C++20)	Envoltorio de objeto función que devuelve el complemento del predicado binario que mantiene. (plantilla de clase)
not1 (en desuso en C++17)(eliminado en C++20)	Construye un objeto std::unary_negate personalizado. (plantilla de función)
not2 (en desuso en C++17)(eliminado en C++20)	Construye un objeto std::binary_negate personalizado. (plantilla de función)

Sinopsis

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

  // reference_wrapper
  template<class T> class reference_wrapper;

  template<class T> constexpr reference_wrapper<T> ref(T&) noexcept;
  template<class T> constexpr reference_wrapper<const T> cref(const T&) noexcept;
  template<class T> void ref(const T&&) = delete;
  template<class T> void cref(const T&&) = delete;

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

  template<class T> struct unwrap_reference;
  template<class T> using unwrap_reference_t = typename unwrap_reference<T>::type;
  template<class T> struct unwrap_ref_decay;
  template<class T> using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type;

  // operaciones aritméticas
  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>;

  // comparaciones
  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>;

  // operaciones lógicas
  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>;

  // operaciones de bits
  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>;

  // identidad
  struct identity;

  // plantilla de función not_fn
  template<class F> constexpr /* no especificado */ not_fn(F&& f);

  // plantilla de función bind_front
  template<class F, class... Args> constexpr /* no especificado */ bind_front(F&&, Args&&...);

  // vincular
  template<class T> struct is_bind_expression;
  template<class T> struct is_placeholder;

  template<class F, class... BoundArgs>
    constexpr /* no especificado */ bind(F&&, BoundArgs&&...);
  template<class R, class F, class... BoundArgs>
    constexpr /* no especificado */ bind(F&&, BoundArgs&&...);

  namespace placeholders {
    // M el número de marcadores de posición definido por la implementación
    /* véase descripción */ _1;
    /* véase descripción */ _2;
               .
               .
               .
    /* véase descripción */ _M;
  }

  // adaptadores de funciones miembro
  template<class R, class T>
    constexpr /* no especificado */ mem_fn(R T::*) noexcept;

  // envoltorios de función polimórficos
  class bad_function_call;

  template<class> class function; // no definida
  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;

  // searchers
  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;

  // plantilla de función primaria hash
  template<class T>
    struct hash;

  // vinculadores de funciones objeto
  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 {
    // comparaciones restringidas por conceptos
    struct equal_to;
    struct not_equal_to;
    struct greater;
    struct less;
    struct greater_equal;
    struct less_equal;
  }
}

Plantilla de clase std::reference_wrapper

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

    // construcción/copia/destrucción
    template<class U>
      constexpr reference_wrapper(U&&) noexcept(see below);
    constexpr reference_wrapper(const reference_wrapper& x) noexcept;

    // asignación
    constexpr reference_wrapper& operator=(const reference_wrapper& x) noexcept;

    // acceso
    constexpr operator T& () const noexcept;
    constexpr T& get() const noexcept;

    // invocación
    template<class... ArgTypes>
      constexpr invoke_result_t<T&, ArgTypes...> operator()(ArgTypes&&...) const;
  };
  template<class T>
    reference_wrapper(T&) -> reference_wrapper<T>;
}

Plantilla de clase std::unwrap_reference

namespace std {
  template<class T>
    struct unwrap_reference;
}

Plantilla de clase std::unwrap_ref_decay

namespace std {
  template<class T>
    struct unwrap_ref_decay;
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Clase std::ranges::equal_to

namespace std::ranges {
  struct equal_to {
    template<class T, class U>
      requires equality_comparable_with<T, U> || /*COMP-PTR-INTEGRADO*/(T, ==, U)
    constexpr bool operator()(T&& t, U&& u) const;

    using is_transparent = /* no especificado */;
  };
}

Clase std::ranges::not_equal_to

namespace std::ranges {
  struct not_equal_to {
    template<class T, class U>
      requires equality_comparable_with<T, U> || /*COMP-PTR-INTEGRADO*/(T, ==, U)
    constexpr bool operator()(T&& t, U&& u) const;

    using is_transparent = /* no especificado */;
  };
}

Clase std::ranges::greater

namespace std::ranges {
  struct greater {
    template<class T, class U>
      requires totally_ordered_with<T, U> || /*COMP-PTR-INTEGRADO*/(U, <, T)
    constexpr bool operator()(T&& t, U&& u) const;

    using is_transparent = /* no especificado */;
  };
}

Clase std::ranges::less

namespace std::ranges {
  struct less {
    template<class T, class U>
      requires totally_ordered_with<T, U> || /*COMP-PTR-INTEGRADO*/(T, <, U)
    constexpr bool operator()(T&& t, U&& u) const;

    using is_transparent = /* no especificado */;
  };
}

Clase std::ranges::greater_equal

namespace std::ranges {
  struct greater_equal {
    template<class T, class U>
      requires totally_ordered_with<T, U> || /*COMP-PTR-INTEGRADO*/(T, <, U)
    constexpr bool operator()(T&& t, U&& u) const;

    using is_transparent = /* no especificado */;
  };
}

Clase std::ranges::less_equal

namespace std::ranges {
  struct less_equal {
    template<class T, class U>
      requires totally_ordered_with<T, U> || /*COMP-PTR-INTEGRADO*/(U, <, T)
    constexpr bool operator()(T&& t, U&& u) const;

    using is_transparent = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Plantilla de clase std::identity

namespace std {
  struct identity {
    template<class T>
      constexpr T&& operator()(T&& t) const noexcept;

    using is_transparent = /* no especificado */;
  };
}

Plantilla de clase std::is_bind_expression

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

Plantilla de clase std::is_placeholder

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

Clase std::bad_function_call

namespace std {
  class bad_function_call : public exception {
  public:
    // véase [exception] para la especificación de funciones miembro especiales
    const char* what() const noexcept override;
  };
}

Clase std::function

namespace std {
  template<class> class function; // no definida

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

    // construcción/copia/destrucción
    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();

    // modificadores de funciones
    void swap(function&) noexcept;

    // capacidad de funciones
    explicit operator bool() const noexcept;

    // invocación de funciones
    R operator()(ArgTypes...) const;

    // acceso a función objetivo
    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</* véase descripción */>;

  // funciones de comparación con puntero nulo
  template<class R, class... ArgTypes>
    bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;

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

Plantilla de clase 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_;            // solo exposición
      ForwardIter1 pat_last_;             // solo exposición
      BinaryPredicate pred_;              // solo exposición
  };
}

Plantilla de clase 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_;       // solo exposición
      RandomAccessIter1 pat_last_;        // solo exposición
      Hash hash_;                         // solo exposición
      BinaryPredicate pred_;              // solo exposición
    };
}

Plantilla de clase 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_;       // solo exposición
      RandomAccessIter1 pat_last_;        // solo exposición
      Hash hash_;                         // solo exposición
      BinaryPredicate pred_;              // solo exposición
  };
}

Véase también

<string>	Especializa a std::hash para std::string, std::u16string, std::u32string, std::wstring
<system_error>	Especializa a std::hash para std::error_code
<bitset>	Especializa a std::hash para std::bitset
<memory>	Especializa a std::hash para std::unique_ptr, std::shared_ptr
<typeindex>	Especializa a std::hash para std::type_index
<vector>	Especializa a std::hash para std::vector<bool>
<thread>	Especializa a std::hash para std::thread::id