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

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios 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 apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica (C++20) Servicios del programa Apoyo de corrutinas (C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::pair

Funciones miembro

pair::pair

pair::operator=

pair::swap

Funciones no miembro

make_pair

operator==operator!=operator<operator<=operator>operator>=operator<=> (hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(C++20)

std::swap

get (C++11)

Guías de deducción(C++17)

Clases auxiliares

tuple_size (C++11)

tuple_element (C++11)

 

<tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody>

Definido en el archivo de encabezado <utility>
	(1)
template< class T1, class T2 > bool operator==( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );			(hasta C++14)
template< class T1, class T2 > constexpr bool operator==( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );			(desde C++14)
		(2)
template< class T1, class T2 > bool operator!=( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );				(hasta C++14)
template< class T1, class T2 > constexpr bool operator!=( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );				(desde C++14) (hasta C++20)
			(3)
template< class T1, class T2 > bool operator<( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );					(hasta C++14)
template< class T1, class T2 > constexpr bool operator<( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );					(desde C++14) (hasta C++20)
				(4)
template< class T1, class T2 > bool operator<=( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );						(hasta C++14)
template< class T1, class T2 > constexpr bool operator<=( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );						(desde C++14) (hasta C++20)
					(5)
template< class T1, class T2 > bool operator>( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );							(hasta C++14)
template< class T1, class T2 > constexpr bool operator>( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );							(desde C++14) (hasta C++20)
						(6)
template< class T1, class T2 > bool operator>=( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );								(hasta C++14)
template< class T1, class T2 > constexpr bool operator>=( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );								(desde C++14) (hasta C++20)
template< class T1, class T2 > constexpr /* véase más abajo */ operator<=>( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );							(7)	(desde C++20)

1-2) Comprueba si los elementos de lhs y rhs son iguales, es decir, compara lhs.first con rhs.first y lhs.second con rhs.second.

3-6) Compara lhs y rhs lexicográficamente mediante el operador operator<, es decir, compara los primeros elementos y solo si son equivalentes, compara los segundos elementos.

7) Compara lhs and rhs lexicográficamente mediante la comparación de tres vías sintetizada (véase más abajo), es decir, compara los primeros elementos y solo si son equivalentes, compara los segundos elementos.

See More

El tipo de retorno es el tipo de categoría de comparación común del tipo resultado de la comparación de tres vías sintetizada en T1 y el de T2.

Los operadores <, <=, >, >=, y != se sintetizan de operator<=> y operator==, respectivamente.

(desde C++20)

Comparación de tres vías sintetizada Dado un tipo objeto T, dos l-valores const T, lhs y rhs como el operando del lado izquierdo y el operando del lado derecho respectivamente, la comparación de tres vías sintetizada se define como: si std::three_way_comparable_with<T, T> se satisface, es equivalente a lhs <=> rhs; de lo contrario, si la comparación de dos l-valores const T mediante el operador operator< está bien formada y el tipo resultado satisface comprobable-booleano, es equivalente a lhs < rhs ? std::weak_ordering::less : rhs < lhs ? std::weak_ordering::greater : std::weak_ordering::equivalent de lo contrario, la comparación de tres vías sintetizada no se define, lo que hace que el operador operator<=> no participe en la resolución de sobrecargas. El comportamiento del operador operator<=> no está definido si three_way_comparable_with o comprobable-booleano se satisface pero no se modela.

(desde C++20)

Parámetros

lhs, rhs

-

Los pares a comparar.

Valor de retorno

1) true si lhs.first == rhs.first y lhs.second == rhs.second, 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), donde synth_three_way es un objeto función de solo exposición que realiza la comparación de tres vías sintetizada.

Ejemplo

Ya que el operador operator< se define para pares, los contenedores de pares se pueden ordenar.

Ejecuta este código

#include <iostream>
#include <iomanip>
#include <utility>
#include <vector>
#include <algorithm>
#include <string>

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"}

Véase también

operator==operator!=operator<operator<=operator>operator>=

Compara lexicográficamente los valores de la tupla (plantilla de función)