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 > /* see below */ 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 для двух multimap с объектом функции, выполняющей *синтезированное сравнение с тремя значениями* (см. ниже). Тип возвращаемого значения совпадает с типом результата синтезированного сравнения с тремя значениями. Это сравнение игнорирует порядок сортировки multimap Compare.

Для двух const E левых значений lhs и rhs в качестве левого и правого операндов соответственно (где E это std::pair<const Key, T>), *синтезированное сравнение с тремя значениями* определяется следующим образом:

если выполняется std::three_way_comparable_with<E, E>, эквивалентно lhs <=> rhs;
в противном случае, если сравнение двух const E левых значений с помощью оператора< корректно и тип результата удовлетворяет *boolean-testable*, эквивалентно

lhs < rhs ? std::weak_ordering::less :
rhs < lhs ? std::weak_ordering::greater :
            std::weak_ordering::equivalent

в противном случае, синтезированное сравнение с тремя значениями не определено, и оператор<=> не участвует в разрешении перегрузки.

Поведение оператора<=> не определено, если three_way_comparable_with или *boolean-testable* выполняется, но не моделируется, или оператор< используется, но E и < не устанавливают полную упорядоченность.

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

(с 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.

Пример

#include <cassert>
#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 &&
    "");
}

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