std::common_reference

 

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

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica (C++20) Servicios del programa Apoyo de corrutinas (C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Apoyo de tipos

Tipos básicos
Tipos fundamentales
Tipos enteros de anchura fija (C++11)
ptrdiff_t size_t max_align_t (C++11) byte (C++17)	nullptr_t (C++11) offsetof NULL
Límites numéricos
numeric_limits
Interfaz de C de límites numéricos
Información de tipo en tiempo de ejecución
type_info type_index (C++11)	bad_typeid bad_cast
Rasgos de tipos
Categorías de tipos
is_void (C++11) is_null_pointer (C++14) is_array (C++11) is_pointer (C++11) is_enum (C++11) is_union (C++11) is_class (C++11) is_function (C++11)	is_object (C++11) is_scalar (C++11) is_compound (C++11) is_integral (C++11) is_floating_point (C++11) is_fundamental (C++11) is_arithmetic (C++11)
is_reference (C++11)
is_lvalue_reference (C++11)
is_rvalue_reference (C++11)
is_member_pointer (C++11)
is_member_object_pointer (C++11)
is_member_function_pointer (C++11)

Propiedades de tipos
is_const (C++11) is_volatile (C++11) is_empty (C++11) is_polymorphic (C++11) is_final (C++14) is_abstract (C++11) is_aggregate (C++17) is_trivial (C++11)	is_trivially_copyable (C++11) is_standard_layout (C++11) is_literal_type (C++11)(hasta C++20) is_pod (C++11)(en desuso en C++20) is_signed (C++11) is_unsigned (C++11) is_bounded_array (C++20) is_unbounded_array (C++20)
has_unique_object_representations (C++17)
Constantes de rasgos de tipos
integral_constantbool_constanttrue_typefalse_type (C++11)(C++17)(C++11)(C++11)
Metafunciones
conjunction (C++17)
disjunction (C++17)
negation (C++17)
Contexto de evaluación constante
is_constant_evaluated (C++20)

Operaciones soportadas
is_constructibleis_trivially_constructibleis_nothrow_constructible (C++11)(C++11)(C++11)
is_default_constructibleis_trivially_default_constructibleis_nothrow_default_constructible (C++11)(C++11)(C++11)
is_copy_constructibleis_trivially_copy_constructibleis_nothrow_copy_constructible (C++11)(C++11)(C++11)
is_move_constructibleis_trivially_move_constructibleis_nothrow_move_constructible (C++11)(C++11)(C++11)
is_assignableis_trivially_assignableis_nothrow_assignable (C++11)(C++11)(C++11)
is_copy_assignableis_trivially_copy_assignableis_nothrow_copy_assignable (C++11)(C++11)(C++11)
is_move_assignableis_trivially_move_assignableis_nothrow_move_assignable (C++11)(C++11)(C++11)
is_destructibleis_trivially_destructibleis_nothrow_destructible (C++11)(C++11)(C++11)
has_virtual_destructor (C++11)
is_swappable_withis_swappableis_nothrow_swappable_withis_nothrow_swappable (C++17)(C++17)(C++17)(C++17)
Relaciones y consultas de propiedades
is_same (C++11) is_base_of (C++11) is_convertibleis_nothrow_convertible (C++11)(C++20) is_layout_compatible (C++20) is_pointer_interconvertible_base_of (C++20) is_pointer_interconvertible_with_class (C++20) is_corresponding_member (C++20)	alignment_of (C++11) rank (C++11) extent (C++11) is_invocableis_invocable_ris_nothrow_invocableis_nothrow_invocable_r (C++17)(C++17)(C++17)(C++17)
Modificaciones de tipos
remove_cvremove_constremove_volatile (C++11)(C++11)(C++11) add_cvadd_constadd_volatile (C++11)(C++11)(C++11) make_signed (C++11) make_unsigned (C++11)	remove_reference (C++11) add_lvalue_referenceadd_rvalue_reference (C++11)(C++11) remove_pointer (C++11) add_pointer (C++11) remove_extent (C++11) remove_all_extents (C++11)
Transformaciones de tipos
aligned_storage (C++11) aligned_union (C++11) decay (C++11) remove_cvref (C++20) enable_if (C++11) void_t (C++17)	conditional (C++11) common_type (C++11) common_reference (C++20) underlying_type (C++11) result_ofinvoke_result (C++11)(hasta C++20)(C++17) type_identity (C++20)

 

<tbody> </tbody>

Definido en el archivo de encabezado <type_traits>
template< class... T > struct common_reference;		(desde C++20)

See More

Determina el tipo referencia común de los tipos T..., es decir, el tipo al cual todos los tipos en T... pueden convertirse o vincularse. Si tal tipo existe (determinado de acuerdo a las reglas posteriores), el miembro type denomina ese tipo. De lo contrario, no hay un miembro type. El comportamiento está indefinido si cualquiera de los tipos en T... es un tipo incompleto que no sea (posiblemente calificado-cv) void.

Cuando se le dan tipos referencia, common_reference intenta encontrar un tipo referencia al que todos los tipos referencia proporcionados puedan estar vinculados, pero puede devolver un tipo que no sea de referencia si no puede encontrar dicho tipo referencia.

• Si sizeof...(T) es cero, no hay miembro type.
• Si sizeof...(T) es uno (p. ej., T... contiene solo un tipo T0), el miembro type denomina el mismo tipo que T0.
• Si sizeof...(T) es dos (p. ej., T... contiene dos tipos, T1 y T2):
  • Si T1 y T2 son ambos tipos referencia, y el tipo referencia común simple S de T1 y T2 (como se define posteriormente) existe, entonces el tipo miembro type denomina S;
  • De lo contrario, si std::basic_common_reference<std::remove_cvref_t<T1>, std::remove_cvref_t<T2>, T1Q, T2Q>::type existe, donde TiQ es una plantilla de alias tal que TiQ<U> es U con la adición de los calificadores-cv y calificadores-ref de Ti, entonces el tipo miembro type denomina ese tipo;
  • De lo contrario, si decltype(false? val<T1>() : val<T2>()), donde val es una plantilla de función template<class T> T val();, es un tipo válido, entonces el tipo miembro type denomina ese tipo;
  • De lo contrario, si std::common_type_t<T1, T2> es un tipo válido, entonces el tipo miembro type denomina ese tipo;
  • De lo contrario, no hay un miembro type.
• Si sizeof...(T) es mayor que dos (p. ej., T... consiste en los tipos T1, T2, R...), entonces si std::common_reference_t<T1, T2> existe, el miembro type denota std::common_reference_t<std::common_reference_t<T1, T2>, R...> si tal tipo existe. En todos los otros casos, no hay miembro type.

El tipo referencia común simple de dos tipos referencia T1 y T2 se define de la manera siguiente:

• Si T1 es cv1 X & y T2 es cv2 Y & (p. ej., ambos son tipos referencia lvalue): su tipo referencia común es decltype(false? std::declval<cv12 X &>() : std::declval<cv12 Y &>()), donde cv12 es la unión de cv1 y cv2, si ese tipo existe y es un tipo referencia;
• Si T1 y T2 son ambos tipos referencia rvalue: si el tipo referencia común simple de T1 & y T2 & (determinado de acuerdo a la viñeta anterior) existe, entonces dejemos que C denote el tipo referencia rvalue de ese tipo. Si tanto std::is_convertible_v<T1, C> como std::is_convertible_v<T2, C> son true, entonces el tipo referencia común simple de T1 y T2 es C.
• De lo contrario, uno de los dos tipos debe ser un tipo referencia lvalue A & y el otro debe ser un tipo referencia rvalue B && (A y B podrían estar calificados-cv). Dejemos que D denote el tipo referencia común simple de A & y B const &, si lo hay. Si D existe y std::is_convertible_v<B&&, D> es true, entonces el tipo referencia común simple es D.
• De lo contrario, no existe un tipo referencia común simple.

Tipos miembro

Nombre	Definición
type	El tipo referencia común simple para toda T....

Tipos auxiliares

<tbody> </tbody>

template< class... T > using common_reference_t = typename std::common_reference<T...>::type;
template< class T, class U, template<class> class TQual, template<class> class UQual > struct basic_common_reference { };

La plantilla de clase basic_common_reference es un punto de personalización que permite a los usuarios influir en el resultado de common_reference para tipos definidos por el usuario (normalmente referencias proxy). La plantilla principal está vacía.

Especializaciones

Un programa puede especializar a basic_common_reference<T, U, TQual, UQual> en los dos primeros parámetros T y U si std::is_same<T, std::decay_t<T>> y std::is_same<U, std::decay_t<U>> son ambos verdaderos y al menos uno de ellos depende de un tipo definido por el programa .

Si dicha especialización tiene un miembro llamado type, debe ser un tipo miembro público e inequívoco que nombre un tipo al que tanto TQual<T> como UQual<U> son convertibles. Además, std::basic_common_reference<T, U, TQual, UQual>::type y std::basic_common_reference<U, T, UQual, TQual>::type deben denotar el mismo tipo.

Un programa no puede especializar a basic_common_reference en el tercer o cuarto parámetro, ni puede especializar a common_reference. Un programa que agrega especializaciones en violación de estas reglas tiene un comportamiento indefinido.

Notas

Ejemplos

Véase también

common_type (C++11)	Deduce el tipo del resultado de una expresión aritmética mixta (plantilla de clase)
common_reference_with (C++20)	Especifica que dos tipos comparte un tipo de referencia común. (concepto)