Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::pair
Member functions
(C++11)
Non-member functions
operator== operator!= operator< operator<= operator> operator>= operator<=>
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
(C++11)
(C++11)
Helper classes
(C++11)
(C++11)
(C++23)
(C++23)
(C++23)
(C++11)
Deduction guides (C++17)
Definido en el encabezado <utility>
(1)
template < class T1, class T2, class U1, class U2 >
bool operator == ( const std:: pair < T1, T2 > & lhs, const std:: pair < U1, U2 > & rhs ) ;
(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)
(2)
template < class T1, class T2, class U1, class U2 >
bool operator ! = ( const std:: pair < T1, T2 > & lhs, const std:: pair < U1, U2 > & rhs ) ;
(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)
(3)
template < class T1, class T2, class U1, class U2 >
bool operator < ( const std:: pair < T1, T2 > & lhs, const std:: pair < U1, U2 > & rhs ) ;
(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)
(4)
template < class T1, class T2, class U1, class U2 >
bool operator <= ( const std:: pair < T1, T2 > & lhs, const std:: pair < U1, U2 > & rhs ) ;
(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)
(5)
template < class T1, class T2, class U1, class U2 >
bool operator > ( const std:: pair < T1, T2 > & lhs, const std:: pair < U1, U2 > & rhs ) ;
(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)
(6)
template < class T1, class T2, class U1, class U2 >
bool operator >= ( const std:: pair < T1, T2 > & lhs, const std:: pair < U1, U2 > & rhs ) ;
(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) Comprueba 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 es indefinido 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 .

(until C++26)

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

(since 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 es indefinido 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)

Contenidos

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 el tuple
(plantilla de función)