Namespaces
Variants

operator==,!=,<,<=,>,>=,<=> (std::tuple)

From cppreference.net
C++
Utilities library
std::tuple
Definido en el encabezado <tuple>
template < class ... TTypes , class ... UTypes >

bool operator == ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(1) (desde C++11)
(constexpr desde C++14)
template < class ... TTypes , class ... UTypes >

bool operator ! = ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(2) (desde C++11)
(constexpr desde C++14)
(hasta C++20)
template < class ... TTypes , class ... UTypes >

bool operator < ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(3) (desde C++11)
(constexpr desde C++14)
(hasta C++20)
template < class ... TTypes , class ... UTypes >

bool operator <= ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(4) (desde C++11)
(constexpr desde C++14)
(hasta C++20)
template < class ... TTypes , class ... UTypes >

bool operator > ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(5) (desde C++11)
(constexpr desde C++14)
(hasta C++20)
template < class ... TTypes , class ... UTypes >

bool operator >= ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(6) (desde C++11)
(constexpr desde C++14)
(hasta C++20)
template < class ... TTypes , class ... UTypes >

constexpr std:: common_comparison_category_t <
synth - three - way - result < TTypes, Elems > ... >
operator <=> ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(7) (desde C++20)
template < class ... TTypes , tuple - like UTuple >
constexpr bool operator == ( const tuple < TTypes... > & lhs, const UTuple & rhs ) ;
(8) (desde C++23)
template < class ... TTypes , tuple - like UTuple >

constexpr std:: common_comparison_category_t <
synth - three - way - result < TTypes, /* Elementos */ > ... >

operator <=> ( const tuple < TTypes... > & lhs, const UTuple & rhs ) ;
(9) (desde C++23)
1,2) Compara cada elemento de la tupla lhs con el elemento correspondiente de la tupla rhs mediante operator == .
1) Devuelve true si todos los pares de elementos correspondientes son iguales.
2) Devuelve ! ( lhs == rhs ) .
Si sizeof... ( TTypes ) no es igual a sizeof... ( UTypes ) , o std :: get < i > ( lhs ) == std :: get < i > ( rhs ) no es una expresión válida para cualquier i en [ ​ 0 ​ , sizeof... ( Types ) ) , el programa está mal formado.
Si el tipo y la categoría de valor de std :: get < i > ( lhs ) == std :: get < i > ( rhs ) no cumplen con los requisitos de BooleanTestable para cualquier i en [ ​ 0 ​ , sizeof... ( Types ) ) , el comportamiento es indefinido.
(hasta C++26)
Esta sobrecarga participa en la resolución de sobrecarga solo si sizeof... ( TTypes ) es igual a sizeof... ( UTypes ) , std :: get < i > ( lhs ) == std :: get < i > ( rhs ) es una expresión válida y decltype ( std :: get < i > ( lhs ) == std :: get < i > ( rhs ) ) modela boolean-testable para cada i en [ ​ 0 ​ , sizeof... ( Types ) ) .
(desde C++26)
3-6) Compara lhs y rhs lexicográficamente mediante operator < , es decir, compara los primeros elementos, si son equivalentes, compara los segundos elementos, si esos son equivalentes, compara los terceros elementos, y así sucesivamente.
3) Para tuplas vacías, retorna false . Para tuplas no vacías, el efecto es equivalente a
if ( std :: get < 0 > ( lhs ) < std :: get < 0 > ( rhs ) ) return true ;

if ( std :: get < 0 > ( rhs ) < std :: get < 0 > ( lhs ) ) return false ;
if ( std :: get < 1 > ( lhs ) < std :: get < 1 > ( rhs ) ) return true ;
if ( std :: get < 1 > ( rhs ) < std :: get < 1 > ( lhs ) ) return false ;
...

return std :: get < N - 1 > ( lhs ) < std :: get < N - 1 > ( rhs ) ;
4) Devuelve ! ( rhs < lhs ) .
5) Devuelve rhs < lhs .
6) Devuelve ! ( lhs < rhs ) .
Si sizeof... ( TTypes ) no es igual a sizeof... ( UTypes ) , o si alguna de las expresiones de comparación mostradas en las declaraciones equivalentes no es una expresión válida, el programa está mal formado.
Si el tipo y la categoría de valor de cualquiera de las expresiones de comparación mostradas en las declaraciones equivalentes no cumplen con los BooleanTestable requisitos, el comportamiento es indefinido.
7) Compara lhs y rhs lexicográficamente mediante synth-three-way , es decir, compara los primeros elementos, si son equivalentes, compara los segundos elementos, si estos son equivalentes, compara los terceros elementos, y así sucesivamente.

if ( auto c = synth-three-way ( std :: get < 0 > ( lhs ) , std :: get < 0 > ( rhs ) ) ; c ! = 0 ) return c ;
if ( auto c = synth-three-way ( std :: get < 1 > ( lhs ) , std :: get < 1 > ( rhs ) ) ; c ! = 0 ) return c ;
...
return synth-three-way ( std :: get < N - 1 > ( lhs ) , std :: get < N - 1 > ( rhs ) ) ;

8) Igual que (1) , excepto que rhs es un objeto tuple-like , y el número de elementos de rhs está determinado por std:: tuple_size_v < UTuple > en su lugar. Esta sobrecarga solo puede encontrarse mediante búsqueda dependiente de argumentos .
9) Igual que (7) , excepto que rhs es un objeto tuple-like . /* Elems */ denota el paquete de tipos std:: tuple_element_t < i, UTuple > para cada i en [ ​ 0 ​ , std:: tuple_size_v < UTuple > ) en orden creciente. Esta sobrecarga solo puede encontrarse mediante búsqueda dependiente de argumento .

Todos los operadores de comparación están cortocircuitados; no acceden a elementos de la tupla más allá de lo necesario para determinar el resultado de la comparación.

Los operadores < , <= , > , >= y != son sintetizados a partir de operator <=> y operator == respectivamente.

(desde C++20)

Contenidos

Parámetros

lhs, rhs - tuplas a comparar

Valor de retorno

1,8) true si std :: get < i > ( lhs ) == std :: get < i > ( rhs ) para todo i en [ ​ 0 ​ , sizeof... ( Types ) ) , de lo contrario false . Para dos tuplas vacías retorna true .
2) ! ( lhs == rhs )
3) true si el primer elemento no equivalente en lhs es menor que el de rhs , false si el primer elemento no equivalente en rhs es menor que el de lhs o si no hay ningún elemento no equivalente. Para dos tuplas vacías, devuelve false .
4) ! ( rhs < lhs )
5) rhs < lhs
6) ! ( lhs < rhs )
7,9) La relación entre el primer par de elementos no equivalentes si existe alguno, std::strong_ordering::equal en caso contrario. Para dos tuplas vacías, retorna std::strong_ordering::equal .

Notas

Los operadores relacionales se definen en términos del operator < de cada elemento.

(until C++20)

Los operadores relacionales se definen en términos de synth-three-way , que utiliza operator <=> si es posible, o operator < en caso contrario.

Cabe destacar que si un tipo de elemento no proporciona por sí mismo operator <=> , pero es convertible implícitamente a un tipo comparable de tres vías, se utilizará esa conversión en lugar de operator < .

(since C++20)
Macro de prueba de características Valor Estándar Característica
__cpp_lib_constrained_equality 202403L (C++26) Operador operator == restringido para std::tuple

Ejemplo

Debido a que operator < está definido para tuplas, los contenedores de tuplas pueden ser ordenados.

Ejecutar este código 
#include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
int main()
{
    std::vector<std::tuple<int, std::string, float>> v
    {
        {2, "baz", -0.1},
        {2, "bar", 3.14},
        {1, "foo", 10.1},
        {2, "baz", -1.1},
    };
    std::sort(v.begin(), v.end());
    for (const auto& p: v)
        std::cout << "{ " << get<0>(p)
                  << ", " << get<1>(p)
                  << ", " << get<2>(p)
                  << " }\n";
}

Salida: 

{ 1, foo, 10.1 }
{ 2, bar, 3.14 }
{ 2, baz, -1.1 }
{ 2, baz, -0.1 }

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2114
( P2167R3 ) 		C++11 faltaban precondiciones de tipo para operaciones booleanas añadidas

Véase también

(eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (C++20)
compara lexicográficamente los valores en el pair
(plantilla de función)