Namespaces
Variants

std:: equality_comparable, std:: equality_comparable_with

From cppreference.net
C++
Concepts library
Exposition-only concepts
 (C++20)
Definido en el encabezado <concepts>
template < class T >
concept equality_comparable = __WeaklyEqualityComparableWith < T, T > ;
(1) (desde C++20)
template < class T, class U >

concept equality_comparable_with =
std :: equality_comparable < T > &&
std :: equality_comparable < U > &&
__ComparisonCommonTypeWith < T, U > &&
std :: equality_comparable <
std:: common_reference_t <
const std:: remove_reference_t < T > & ,
const std:: remove_reference_t < U > & >> &&

__WeaklyEqualityComparableWith < T, U > ;
(2) (desde C++20)
Conceptos auxiliares
template < class T, class U >

concept __WeaklyEqualityComparableWith =
requires ( const std:: remove_reference_t < T > & t,
const std:: remove_reference_t < U > & u ) {
{ t == u } - > boolean-testable ;
{ t ! = u } - > boolean-testable ;
{ u == t } - > boolean-testable ;
{ u ! = t } - > boolean-testable ;

} ;
(3) ( solo para exposición* )
(4)
template < class T, class U >

concept __ComparisonCommonTypeWith =
std:: common_reference_with <
const std:: remove_reference_t < T > & ,

const std:: remove_reference_t < U > & > ;
(hasta C++23)
( solo para exposición* )
template < class T, class U, class C = std:: common_reference_t < const T & , const U & > >

concept _ComparisonCommonTypeWithImpl =
std:: same_as < std:: common_reference_t < const T & , const U & > ,
std:: common_reference_t < const U & , const T & >> &&
requires {
requires std:: convertible_to < const T & , const C & > ||
std:: convertible_to < T, const C & > ;
requires std:: convertible_to < const U & , const C & > ||
std:: convertible_to < U, const C & > ;
} ;
template < class T, class U >
concept __ComparisonCommonTypeWith =

_ComparisonCommonTypeWithImpl < std:: remove_cvref_t < T > , std:: remove_cvref_t < U >> ;
(desde C++23)
( solo para exposición* )
1) El concepto std::equality_comparable especifica que los operadores de comparación == y != en T reflejan igualdad: == produce true si y solo si los operandos son iguales.
2) El concepto std::equality_comparable_with especifica que los operadores de comparación == y != en operandos (posiblemente mixtos) de T y U producen resultados consistentes con la igualdad. La comparación de operandos mixtos produce resultados equivalentes a comparar los operandos convertidos a su tipo común.
3) El concepto de solo exposición __WeaklyEqualityComparableWith especifica que un objeto de tipo T y un objeto de tipo U pueden ser comparados para igualdad entre sí (en cualquier orden) usando tanto == como != , y los resultados de las comparaciones son consistentes.
4) El concepto de exposición-exclusiva __ComparisonCommonTypeWith especifica que dos tipos comparten un tipo común, y un lvalue constante o un rvalue no constante (desde C++23) de cualquiera de los tipos es convertible a ese tipo común.

Contenidos

Requisitos semánticos

Estos conceptos se modelan solo si se satisfacen y todos los conceptos que subsumen están modelados.

En los siguientes párrafos, dada una expresión E y un tipo C , CONVERT_TO < C > ( E ) se define como:

(hasta C++23)
  • static_cast < const C & > ( std:: as_const ( E ) ) si es una expresión válida,
  • static_cast < const C & > ( std :: move ( E ) ) en caso contrario.
(desde C++23)
1) std :: equality_comparable < T > se modela solo si, dados los objetos a y b de tipo T , bool ( a == b ) es true si y solo si a y b son iguales. Junto con el requisito de que a == b es que preserva la igualdad , esto implica que == es simétrico y transitivo, y además que == es reflexivo para todos los objetos a que son iguales al menos a otro objeto.
2) std :: equality_comparable_with < T, U > se modela solo si, sean

la siguiente expresión es verdadera:

  • bool ( t == u ) == bool ( CONVERT_TO < C > ( t2 ) == CONVERT_TO < C > ( u2 ) ) .
3) __WeaklyEqualityComparableWith < T, U > se modela solo si, dados

se cumplen las siguientes condiciones:

  • t == u , u == t , t ! = u , u ! = t tienen el mismo dominio;
  • bool ( u == t ) == bool ( t == u ) ;
  • bool ( t ! = u ) == ! bool ( t == u ) ; y
  • bool ( u ! = t ) == bool ( t ! = u ) .
4) __WeaklyEqualityComparableWith < T, U > se modela solo si:

El concepto correspondiente common_reference_with está modelado.

(hasta C++23)

Sea

se cumplen las siguientes condiciones:

  • CONVERT_TO < C > ( t1 ) es igual a CONVERT_TO < C > ( t2 ) si y solo si t1 es igual a t2 ; y
  • CONVERT_TO < C > ( u1 ) es igual a CONVERT_TO < C > ( u2 ) si y solo si u1 es igual a u2 .
(desde C++23)

Preservación de la igualdad

Las expresiones declaradas en las requires expressions de los conceptos de la biblioteca estándar deben ser equality-preserving (excepto cuando se indique lo contrario).

Variaciones de expresión implícita

Una requires expresión que utiliza una expresión que no modifica para algún operando constante lvalue también requiere variaciones de expresión implícitas .

Referencias

  • Estándar C++23 (ISO/IEC 14882:2024):
  • 18.5.4 Concepto equality_comparable [concept.equalitycomparable]
  • Estándar C++20 (ISO/IEC 14882:2020):
  • 18.5.3 Concepto equality_comparable [concept.equalitycomparable]