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)

 

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<signedchar>; template<>struct hash<unsignedchar>; template<>struct hash<char16_t>; template<>struct hash<char32_t>; template<>struct hash<wchar_t>; template<>struct hash<short>; template<>struct hash<unsignedshort>; template<>struct hash<int>; template<>struct hash<unsignedint>; template<>struct hash<long>; template<>struct hash<longlong>; template<>struct hash<unsignedlong>; template<>struct hash<unsignedlonglong>; template<>struct hash<float>; template<>struct hash<double>; template<>struct hash<longdouble>; 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 {// invoketemplate<class F, class... Args>constexpr invoke_result_t<F, Args...> invoke(F&& f, Args&&... args)noexcept(is_nothrow_invocable_v<F, Args...>);   // reference_wrappertemplate<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éticastemplate<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>;   // comparacionestemplate<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ógicastemplate<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 bitstemplate<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>;   // identidadstruct identity;   // plantilla de función not_fntemplate<class F>constexpr/* no especificado */ not_fn(F&& f);   // plantilla de función bind_fronttemplate<class F, class... Args>constexpr/* no especificado */ bind_front(F&&, Args&&...);   // vinculartemplate<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 miembrotemplate<class R, class T>constexpr/* no especificado */ mem_fn(R T::*)noexcept;   // envoltorios de función polimórficosclass bad_function_call;   template<class>class function;// no definidatemplate<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;   // searcherstemplate<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 hashtemplate<class T>struct hash;   // vinculadores de funciones objetotemplate<class T>inlineconstexprbool is_bind_expression_v = is_bind_expression<T>::value;template<class T>inlineconstexprint is_placeholder_v = is_placeholder<T>::value;   namespace ranges {// comparaciones restringidas por conceptosstruct 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:// tiposusing type = T;   // construcción/copia/destruccióntemplate<class U>constexpr reference_wrapper(U&&)noexcept(see below);constexpr reference_wrapper(const reference_wrapper& x)noexcept;   // asignaciónconstexpr reference_wrapper& operator=(const reference_wrapper& x)noexcept;   // accesoconstexpr operator T&()constnoexcept;constexpr T& get()constnoexcept;   // invocacióntemplate<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>constexprauto 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>constexprauto 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>constexprauto 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>constexprauto 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>constexprauto 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>constexprauto 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 {constexprbool operator()(const T& x, const T& y)const;};   template<>struct equal_to<void>{template<class T, class U>constexprauto 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 {constexprbool operator()(const T& x, const T& y)const;};   template<>struct not_equal_to<void>{template<class T, class U>constexprauto 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 {constexprbool operator()(const T& x, const T& y)const;};   template<>struct greater<void>{template<class T, class U>constexprauto 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 {constexprbool operator()(const T& x, const T& y)const;};   template<>struct less<void>{template<class T, class U>constexprauto 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 {constexprbool operator()(const T& x, const T& y)const;};   template<>struct greater_equal<void>{template<class T, class U>constexprauto 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 {constexprbool operator()(const T& x, const T& y)const;};   template<>struct less_equal<void>{template<class T, class U>constexprauto 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)constexprbool 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)constexprbool 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)constexprbool 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)constexprbool 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)constexprbool 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)constexprbool 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 {constexprbool operator()(const T& x, const T& y)const;};   template<>struct logical_and<void>{template<class T, class U>constexprauto 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 {constexprbool operator()(const T& x, const T& y)const;};   template<>struct logical_or<void>{template<class T, class U>constexprauto 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 {constexprbool operator()(const T& x)const;};   template<>struct logical_not<void>{template<class T>constexprauto 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>constexprauto 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>constexprauto 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>constexprauto 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>constexprauto 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)constnoexcept;   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 especialesconstchar* what()constnoexcept 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 funcionesvoid swap(function&)noexcept;   // capacidad de funcionesexplicit operator bool()constnoexcept;   // invocación de funciones R operator()(ArgTypes...)const;   // acceso a función objetivoconst type_info& target_type()constnoexcept;template<class T> T* target()noexcept;template<class T>const T* target()constnoexcept;};   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 nulotemplate<class R, class... ArgTypes>bool operator==(const function<R(ArgTypes...)>&, nullptr_t)noexcept;   // algoritmos especializadostemplate<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