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

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

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

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

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

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

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

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

Тип возвращаемого значения совпадает с типом возвращаемого значения synth-three-way (то есть synth-three-way-result <T>).

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

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

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

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

Параметры

lhs, rhs	-	`multiset`, содержимое которых нужно сравнить
-`Key` должен удовлетворять требованиям EqualityComparable для использования перегрузок (1,2).

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

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

2) true, если содержимое multiset не совпадает, иначе 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 имеют разный размер, в противном случае линейная относительно размера multiset.

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

Примечания

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

(до C++20)

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

В частности, если сам элемент не предоставляет operator<=>, но неявно преобразуется к типу, допускающему трёхстороннее сравнение, вместо operator< будет использоваться это преобразование.

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

Пример

#include <cassert>
#include <compare>
#include <set>

int main()
{
    const std::multiset
        a{1, 2, 3},
        b{1, 2, 3},
        c{7, 8, 9, 10};

    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/multiset/operator_cmp