Namespaces
Variants

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

    De es.cppreference.net
     
    C++
    Soporte del compilador
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades 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 soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de utilidades
    Soporte del lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de la biblioteca (C++20)
    Utilidades del programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Soporte de corrutinas (C++20)
    Soporte de contratos (C++26)
    Comparación de tres vías
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilidades generales
    Operadores relacionales (obsoleto en C++20)
     
    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, /* Elems */>...>
    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 ningún 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 ningún i en [0, sizeof...(Types)), el comportamiento no está definido.
    		(hasta C++26)
    Esta sobrecarga solo participa en la resolución de sobrecarga 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)) modelan 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, devuelve 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 cualquiera 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 requisitos de BooleanTestable, el comportamiento no está definido.
    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 esos 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 se determina mediante std::tuple_size_v<UTuple> en su lugar. Esta sobrecarga solo se puede encontrar 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 se puede encontrar mediante búsqueda dependiente de argumentos.

    Todos los operadores de comparación son de cortocircuito; 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)

    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)