Namespaces
Variants

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

    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 de 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::pair
     
    Definido en el encabezado <utility> 
    template< class T1, class T2, class U1, class U2 >
bool operator==( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(1) (hasta C++14) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator==( const std::pair<T1, T2>& lhs,
                           const std::pair<U1, U2>& rhs );
    		(desde C++14) 
    template< class T1, class T2, class U1, class U2 >
bool operator!=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(2) (hasta C++14) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator!=( const std::pair<T1, T2>& lhs,
                           const std::pair<U1, U2>& rhs );
    		(desde C++14)
    (hasta C++20)    		 
    template< class T1, class T2, class U1, class U2 >
bool operator<( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(3) (hasta C++14) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator<( const std::pair<T1, T2>& lhs,
                          const std::pair<U1, U2>& rhs );
    		(desde C++14)
    (hasta C++20)    		 
    template< class T1, class T2, class U1, class U2 >
bool operator<=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(4) (hasta C++14) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator<=( const std::pair<T1, T2>& lhs,
                           const std::pair<U1, U2>& rhs );
    		(desde C++14)
    (hasta C++20)    		 
    template< class T1, class T2, class U1, class U2 >
bool operator>( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(5) (hasta C++14) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator>( const std::pair<T1, T2>& lhs,
                          const std::pair<U1, U2>& rhs );
    		(desde C++14)
    (hasta C++20)    		 
    template< class T1, class T2, class U1, class U2 >
bool operator>=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(6) (hasta C++14) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator>=( const std::pair<T1, T2>& lhs,
                           const std::pair<U1, U2>& rhs );
    		(desde C++14)
    (hasta C++20)    		 
    template< class T1, class T2, class U1, class U2 >
constexpr std::common_comparison_category_t<synth-three-way-result<T1, U1>,
                                            synth-three-way-result<T2, U2>>
    operator<=>( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(7) (desde C++20)
    1,2) Prueba si ambos elementos de lhs y rhs son iguales, es decir, compara lhs.first con rhs.first y lhs.second con rhs.second.

    El comportamiento no está definido si el tipo y la categoría de valor de lhs.first == rhs.first o lhs.second == rhs.second no cumplen con los requisitos de BooleanTestable.

    		(hasta C++26)

    Esta sobrecarga solo participa en la resolución de sobrecarga si tanto decltype(lhs.first == rhs.first) como decltype(lhs.second == rhs.second) modelan boolean-testable.

    		(desde C++26)
    3-6) Compara lhs y rhs lexicográficamente mediante operator<, es decir, compara los primeros elementos y solo si son equivalentes, compara los segundos elementos. El comportamiento no está definido si el tipo y la categoría de valor de cualquiera de lhs.first < rhs.first, rhs.first < lhs.first o lhs.second < rhs.second no cumplen con los requisitos de BooleanTestable.
    7) Compara lhs y rhs lexicográficamente mediante synth-three-way, es decir, compara los primeros elementos y solo si son equivalentes, compara los segundos elementos. synth-three-way-result es el tipo de retorno de synth-three-way.

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

    		(desde C++20)

    Parámetros

    lhs, rhs - pares a comparar

    Valor de retorno

    1) true si tanto lhs. first == rhs. first como lhs. second == rhs. second son verdaderos, de lo contrario false .
    2) ! ( lhs == rhs )
    3) Si lhs. first < rhs. first , devuelve true . De lo contrario, si rhs. first < lhs. first , devuelve false . De lo contrario, si lhs. second < rhs. second , devuelve true . De lo contrario, devuelve false .
    4) ! ( rhs < lhs )
    5) rhs < lhs
    6) ! ( lhs < rhs )
    7) synth-three-way ( lhs. first , rhs. first ) si no es igual a ​ 0 ​ , de lo contrario synth-three-way ( lhs. second , rhs. second ) .

    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 Std Característica
    __cpp_lib_constrained_equality 202403L (C++26) Operador operator == restringido para std::pair

    Ejemplo

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

    Ejecutar este código 
    #include <algorithm>
#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
int main()
{
    std::vector<std::pair<int, std::string>> v = {{2, "baz"}, {2, "bar"}, {1, "foo"}};
    std::sort(v.begin(), v.end());
    for (auto p : v)
        std::cout << '{' << p.first << ", " << std::quoted(p.second) << "}\n";
}

    Salida: 

    {1, "foo"}
{2, "bar"}
{2, "baz"}

    Informes de defectos

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

    DR Aplicado a Comportamiento publicado Comportamiento correcto
    LWG 296 C++98 faltaban las descripciones de operadores distintos a == y < añadidas
    LWG 2114
    ( P2167R3 )     		C++98 faltaban precondiciones de tipo para operaciones booleanas añadidas
    LWG 3865 C++98 los operadores de comparación solo aceptaban pair s del mismo tipo aceptan pair s de tipos diferentes

    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 la tupla
    (plantilla de función)