std::common_with

 

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 conceptos

Conceptos del lenguaje principales
same_as derived_from convertible_to common_reference_with common_with integral signed_integral unsigned_integral floating_point swappableswappable_with destructible constructible_from default_initializable move_constructible copy_constructible assignable_from	Conceptos de comparación equality_comparableequality_comparable_with totally_orderedtotally_ordered_with Conceptos de objetos movable copyable semiregular regular Conceptos invocables invocableregular_invocable predicate relation equivalence_relation strict_weak_order

 

Definido en el archivo de encabezado <concepts>
template<class T, class U> concept common_with =   std::same_as<std::common_type_t<T, U>, std::common_type_t<U, T>>&&   requires {     static_cast<std::common_type_t<T, U>>(std::declval<T>());     static_cast<std::common_type_t<T, U>>(std::declval<U>());   }&&   std::common_reference_with<     std::add_lvalue_reference_t<const T>,     std::add_lvalue_reference_t<const U>>&&   std::common_reference_with<     std::add_lvalue_reference_t<std::common_type_t<T, U>>,     std::common_reference_t<       std::add_lvalue_reference_t<const T>,       std::add_lvalue_reference_t<const U>>>;		(desde C++20)

El concepto common_with<T, U> especifica que dos tipos T and U comparten un tipo común (computado por std::common_type_t) al cual ambos pueden ser convertidos.

T y U modelan common_with<T, U> solamente si, dadas las expresiones conservadoras de igualdad t1, t2, u1 y u2 tales que decltype((t1)) y decltype((t2)) son ambas T y decltype((u1)) y decltype((u2)) son ambas U,

• std::common_type_t<T, U>(t1) es igual a std::common_type_t<T, U>(t2) si y solo si t1 es igual a t2; y
• std::common_type_t<T, U>(u1) es igual a std::common_type_t<T, U>(u2) si y solo si u1 es igual a u2.

En otras palabras, la conversión al tipo común debe conservar la igualdad.

Conservación de la igualdad

Una expresión es conservadora de igualdad si resulta en salidas iguales dadas entradas iguales.

• Las entradas de una expresión consisten en sus operandos.
• Las salidas de una expresión consisten en su resultado y todos los operandos modificados por la expresión (si es que los hay).

Cada expresión que se requiere sea conservadora de igualdad, se requiere además que sea estable: dos evaluaciones de tal expresión con los mismos objetos de entrada debe tener salidas iguales si no se encuentra alguna modificación interventora de esos objetos de entrada.

Véase también

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