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)
Определено в заголовочном файле <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 начиная с 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) (до 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) (до 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) (до 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) (до 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) (до C++20)
template < class Key, class T, class Compare, class Alloc >

/* см. ниже */
operator <=> ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(7) (начиная с C++20)
(constexpr начиная с C++26)

Сравнивает содержимое двух map ов.

Пусть value_type будет типом значения map (т.е., typename map :: value_type ):

1,2) Проверяет, равны ли содержимые lhs и rhs , то есть имеют ли они одинаковое количество элементов и каждый элемент в lhs сравнивается как равный с элементом в rhs на той же позиции.
Эквивалентно:

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

(до C++14)

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

(начиная с C++14)
Если value_type не является EqualityComparable , поведение не определено.
3-7) Сравнивает содержимое lhs и rhs лексикографически.
3-6) Эквивалентно return std:: lexicographical_compare ( lhs. begin ( ) , lhs. end ( ) ,
rhs. begin ( ) , rhs. end ( ) ) ; .
Если выполняется любое из следующих условий, поведение не определено:
7) Эквивалентно return std:: lexicographical_compare_three_way ( lhs. begin ( ) , lhs. end ( ) ,
rhs. begin ( ) , rhs. end ( ) ,
synth-three-way ) .
Тип возвращаемого значения — это тип возвращаемого значения synth-three-way (т.е., synth-three-way-result  < value_type > ).
Если выполняется любое из следующих условий, поведение не определено:
  • T не моделирует three_way_comparable .
  • operator < не определён для значений типа (возможно, const-квалифицированного) value_type .
  • operator < не устанавливает полный порядок .

Операторы < , <= , > , >= и != синтезируются из operator <=> и operator == соответственно.

(начиная с C++20)

Содержание

Параметры

lhs, rhs - map s, содержимое которых нужно сравнить

Возвращаемое значение

Оператор lhs и rhs
равны 		lhs лексикографически
больше 		rhs лексикографически
больше
operator == true false
operator ! = false true
operator < false false true
operator <= true
operator > false true false
operator >= true
operator <=> значение равное ​ 0 ​ значение больше ​ 0 ​ значение меньше ​ 0 ​

Сложность

1,2) Константная, если lhs и rhs имеют разный размер, в противном случае линейная от размера map .
3-7) Линейно от размера map .

Примечания

Операторы сравнения определяются через value_type 's operator < .

(до C++20)

Операторы сравнения не определены. Переписанный кандидат operator <=> будет выбран через разрешение перегрузки.

operator <=> использует value_type 's operator <=> если возможно, или value_type 's operator < в противном случае. В частности, если value_type сам не предоставляет operator <=> , но неявно преобразуется в тип с трехсторонним сравнением, это преобразование будет использовано вместо operator < .

(начиная с C++20)

Эти нечленные операторы сравнения не используют Compare для сравнения элементов.

Пример

Запустить этот код 
#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
    (""
        "Сравнение равных контейнеров:" &&
        (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 &&
        "Сравнение неравных контейнеров:" &&
        (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 &&
    "");
}

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены ретроактивно к ранее опубликованным стандартам C++.

DR Применяется к Поведение в опубликованной версии Корректное поведение
LWG 3431 C++20 operator <=> не требовал T
моделирования three_way_comparable 		требует