Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::map
Member functions
Non-member functions
operator== operator<=>
(C++20)
(C++20)

operator!= operator< operator> operator<= operator>=
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
Definido en el encabezado <map>
template < class Key, class T, class Compare, class Alloc >

bool operator == ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(1) (constexpr desde C++26)
template < class Key, class T, class Compare, class Alloc >

bool operator ! = ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(2) (hasta C++20)
template < class Key, class T, class Compare, class Alloc >

bool operator < ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(3) (hasta C++20)
template < class Key, class T, class Compare, class Alloc >

bool operator <= ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(4) (hasta C++20)
template < class Key, class T, class Compare, class Alloc >

bool operator > ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(5) (hasta C++20)
template < class Key, class T, class Compare, class Alloc >

bool operator >= ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(6) (hasta C++20)
template < class Key, class T, class Compare, class Alloc >

/* ver más abajo */
operator <=> ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(7) (desde C++20)
(constexpr desde C++26)

Compara el contenido de dos map s.

Sea value_type el tipo de valor de map (es decir, typename map :: value_type ):

1,2) Comprueba si los contenidos de lhs y rhs son iguales, es decir, tienen el mismo número de elementos y cada elemento en lhs se compara igual con el elemento en rhs en la misma posición.
Equivalente a:

return std:: distance ( lhs. begin ( ) , lhs. end ( ) )
== std:: distance ( rhs. begin ( ) , rhs. end ( ) )
&& std:: equal ( lhs. begin ( ) , lhs. end ( ) , rhs. begin ( ) ) ;

(hasta C++14)

return std:: equal ( lhs. begin ( ) , lhs. end ( ) , rhs. begin ( ) , rhs. end ( ) ) ;

(desde C++14)
Si value_type no es EqualityComparable , el comportamiento es indefinido.
3-7) Compara los contenidos de lhs y rhs lexicográficamente.
3-6) Equivalente a return std:: lexicographical_compare ( lhs. begin ( ) , lhs. end ( ) ,
rhs. begin ( ) , rhs. end ( ) ) ; .
Si se cumple alguna de las siguientes condiciones, el comportamiento es indefinido:
7) Equivalente a return std:: lexicographical_compare_three_way ( lhs. begin ( ) , lhs. end ( ) ,
rhs. begin ( ) , rhs. end ( ) ,
synth-three-way ) .
El tipo de retorno es el tipo de retorno de synth-three-way (es decir, synth-three-way-result  < value_type > ).
Si se satisface cualquiera de las siguientes condiciones, el comportamiento es indefinido:
  • T no modela three_way_comparable .
  • operator < no está definido para valores de tipo (posiblemente calificado como const) value_type .
  • operator < no establece un orden total .

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

(desde C++20)

Contenidos

Parámetros

lhs, rhs - map s cuyos contenidos comparar

Valor de retorno

Operador lhs y rhs
son iguales 		lhs es
lexicográficamente mayor 		rhs es
lexicográficamente mayor
operator == true false
operator ! = false true
operator < false false true
operator <= true
operator > false true false
operator >= true
operator <=> un valor igual a ​ 0 ​ un valor mayor que ​ 0 ​ un valor menor que ​ 0 ​

Complejidad

1,2) Constante si lhs y rhs tienen tamaños diferentes, de lo contrario lineal con respecto al tamaño del map .
3-7) Lineal en el tamaño del map .

Notas

Los operadores relacionales se definen en términos del value_type 's operator < .

(hasta C++20)

Los operadores relacionales no están definidos. El candidato reescrito operator <=> será seleccionado por resolución de sobrecarga.

operator <=> utiliza el value_type 's operator <=> si es posible, o el value_type 's operator < en caso contrario. Notablemente, si el value_type 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 < .

(desde C++20)

Estos operadores de comparación no miembros no utilizan Compare para comparar elementos.

Ejemplo

Ejecutar este código 
#include <cassert>
#include <compare>
#include <map>
int main()
{
    std::map<int, char> a{{1, 'a'}, {2, 'b'}, {3, 'c'}};
    std::map<int, char> b{{1, 'a'}, {2, 'b'}, {3, 'c'}};
    std::map<int, char> c{{7, 'Z'}, {8, 'Y'}, {9, 'X'}, {10, 'W'}};
    assert
    (""
        "Comparar contenedores iguales:" &&
        (a != b) == false &&
        (a == b) == true &&
        (a < b) == false &&
        (a <= b) == true &&
        (a > b) == false &&
        (a >= b) == true &&
        (a <=> b) != std::weak_ordering::less &&
        (a <=> b) != std::weak_ordering::greater &&
        (a <=> b) == std::weak_ordering::equivalent &&
        (a <=> b) >= 0 &&
        (a <=> b) <= 0 &&
        (a <=> b) == 0 &&
        "Comparar contenedores no iguales:" &&
        (a != c) == true &&
        (a == c) == false &&
        (a < c) == true &&
        (a <= c) == true &&
        (a > c) == false &&
        (a >= c) == false &&
        (a <=> c) == std::weak_ordering::less &&
        (a <=> c) != std::weak_ordering::equivalent &&
        (a <=> c) != std::weak_ordering::greater &&
        (a <=> c) < 0 &&
        (a <=> c) != 0 &&
        (a <=> c) <= 0 &&
    "");
}

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 3431 C++20 operator <=> no requería que T
modele three_way_comparable 		requiere