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

Определён в заголовочном файле `<map>`
template< class Key, class T, class Compare, class Alloc > bool operator==( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs );	(1)
template< class Key, class T, class Compare, class Alloc > bool operator!=( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs );	(2)	(до C++20)
template< class Key, class T, class Compare, class Alloc > bool operator<( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs );	(3)	(до C++20)
template< class Key, class T, class Compare, class Alloc > bool operator<=( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs );	(4)	(до C++20)
template< class Key, class T, class Compare, class Alloc > bool operator>( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs );	(5)	(до C++20)
template< class Key, class T, class Compare, class Alloc > bool operator>=( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs );	(6)	(до C++20)
template< class Key, class T, class Compare, class Alloc > synth-three-way-result<T> operator<=>( const std::multimap<Key, T, Compare, Alloc>& lhs, const std::multimap<Key, T, Compare, Alloc>& rhs );	(7)	(начиная с C++20)

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

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

3-6) Лексикографически сравнивает содержимое lhs и rhs. Сравнение выполняется функцией, эквивалентной std::lexicographical_compare. При этом сравнении порядок multimap, заданный параметром Compare, не учитывается.

7) Лексикографически сравнивает содержимое lhs и rhs. Сравнение выполняется так, как если бы был вызван

std::lexicographical_compare_three_way(lhs.begin(),lhs.end(),
                                       rhs.begin(),rhs.end(), synth-three-way)

. При этом сравнении порядок multimap, заданный параметром Compare, не учитывается.

Возвращаемый тип совпадает с возвращаемым типом synth-three-way (то есть synth-three-way-result <T>).

Если ни одно из следующих условий не выполняется, поведение не определено:

T удовлетворяет требованиям three_way_comparable.
Для значений типа (возможно, с квалификатором const) T определён <, а < является отношением полного порядка.

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

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

Параметры

lhs, rhs	-	`multimap`, содержимое которых нужно сравнить
-`T, Key` должны удовлетворять требованиям EqualityComparable, чтобы использовать перегрузки (1,2).
-`Key` должны удовлетворять требованиям LessThanComparable, чтобы использовать перегрузки (3-6). Отношение порядка должно задавать полный порядок.

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

1) true, если содержимое multimap равно, и false в противном случае.

2) true, если содержимое multimap не равно, и false в противном случае.

3) true, если содержимое lhs лексикографически меньше содержимого rhs, и false в противном случае.

4) true, если содержимое lhs лексикографически меньше или равно содержимому rhs, и false в противном случае.

5) true, если содержимое lhs лексикографически больше содержимого rhs, и false в противном случае.

6) true, если содержимое lhs лексикографически больше или равно содержимому rhs, и false в противном случае.

7) Относительный порядок первой пары неэквивалентных элементов в lhs и rhs, если такие элементы есть, и lhs.size() <=> rhs.size() в противном случае.

Сложность

1,2) Постоянная, если lhs и rhs имеют разный размер; в противном случае — линейная относительно размера multimap.

3-7) Линейная относительно размера multimap.

Примечания

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

(до C++20)

Операторы сравнения определяются через synth-three-way, который использует operator<=>, если это возможно, и operator< в противном случае.

Примечательно, что если сам элемент не предоставляет operator<=>, но неявно преобразуется в тип, сравнимый оператором трёхстороннего сравнения, вместо operator< будет использоваться это преобразование.

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

Пример

#include <cassert>
#include <compare>
#include <map>

int main()
{
    std::multimap<int, char> a{{1, 'a'}, {2, 'b'}, {3, 'c'}};
    std::multimap<int, char> b{{1, 'a'}, {2, 'b'}, {3, 'c'}};
    std::multimap<int, char> c{{7, 'Z'}, {8, 'Y'}, {9, 'X'}, {10, 'W'}};

    assert
    (""
        "Compare equal containers:" &&
        (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 &&

        "Compare non equal containers:" &&
        (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`	требует

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/container/multimap/operator_cmp