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

From cppreference.com

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros(C++20)
Language support library
Concepts library(C++20)
Diagnostics library
Memory management library
Metaprogramming library(C++11)
General utilities library
Containers library
Iterators library
Ranges library(C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library(C++17)
Concurrency support library(C++11)
Execution control library(C++26)
Technical specifications
Symbols index
External libraries

[edit]

Containers library

node-handle (C++17)
Sequence
array (C++11)
vector
vector<bool>
inplace_vector (C++26)
hive (C++26)
deque
forward_list (C++11)
list
Associative
set
multiset
map
multimap
Unordered associative
unordered_set (C++11)
unordered_multiset (C++11)
unordered_map (C++11)
unordered_multimap (C++11)
Adaptors
stack
queue
priority_queue
flat_set (C++23)
flat_multiset (C++23)
flat_map (C++23)
flat_multimap (C++23)
Views
span (C++20)
mdspan (C++23)
Tables
Iterator invalidation
Member function table
Non-member function table

[edit]

std::multiset

Member functions

multiset::multiset
multiset::~multiset

multiset::operator=
multiset::get_allocator

Iterators
multiset::beginmultiset::cbegin (C++11)
multiset::endmultiset::cend (C++11)
multiset::rbeginmultiset::crbegin (C++11)
multiset::rendmultiset::crend (C++11)
Capacity
multiset::size
multiset::max_size
multiset::empty
Observers
multiset::key_comp
multiset::value_comp

Modifiers
multiset::clear
multiset::erase
multiset::swap
multiset::extract (C++17)
multiset::merge (C++17)
multiset::insert
multiset::insert_range (C++23)
multiset::emplace (C++11)
multiset::emplace_hint (C++11)
Lookup
multiset::count
multiset::find
multiset::contains (C++20)
multiset::equal_range
multiset::lower_bound
multiset::upper_bound

Non-member functions

std::swap(std::multiset)
erase_if(std::multiset) (C++20)
operator==operator<=> (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)

[edit]

Defined in header`<set>`
template<class Key,class Compare,class Alloc> bool operator==(conststd::multiset<Key, Compare, Alloc>& lhs, conststd::multiset<Key, Compare, Alloc>& rhs);	(1)	(constexpr since C++26)
template<class Key,class Compare,class Alloc> bool operator!=(conststd::multiset<Key, Compare, Alloc>& lhs, conststd::multiset<Key, Compare, Alloc>& rhs);	(2)	(until C++20)
template<class Key,class Compare,class Alloc> bool operator<(conststd::multiset<Key, Compare, Alloc>& lhs, conststd::multiset<Key, Compare, Alloc>& rhs);	(3)	(until C++20)
template<class Key,class Compare,class Alloc> bool operator<=(conststd::multiset<Key, Compare, Alloc>& lhs, conststd::multiset<Key, Compare, Alloc>& rhs);	(4)	(until C++20)
template<class Key,class Compare,class Alloc> bool operator>(conststd::multiset<Key, Compare, Alloc>& lhs, conststd::multiset<Key, Compare, Alloc>& rhs);	(5)	(until C++20)
template<class Key,class Compare,class Alloc> bool operator>=(conststd::multiset<Key, Compare, Alloc>& lhs, conststd::multiset<Key, Compare, Alloc>& rhs);	(6)	(until C++20)
template<class Key,class Compare,class Alloc> /* see below */ operator<=>(conststd::multiset<Key, Compare, Alloc>& lhs, conststd::multiset<Key, Compare, Alloc>& rhs);	(7)	(since C++20) (constexpr since C++26)

Compares the contents of twomultisets.

Letvalue_type be the value type ofmultiset (i.e.,typename multiset::value_type):

1,2) Checks if the contents oflhs andrhs are equal, that is, they have the same number of elements and each element inlhs compares equal with the element inrhs at the same position.

Equivalent to:

returnstd::distance(lhs.begin(), lhs.end()) ==std::distance(rhs.begin(), rhs.end()) &&std::equal(lhs.begin(), lhs.end(), rhs.begin());	(until C++14)
returnstd::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());	(since C++14)

Ifvalue_type is notEqualityComparable, the behavior is undefined.

3-7) Compares the contents oflhs andrhs lexicographically.

3-6) Equivalent toreturnstd::lexicographical_compare(lhs.begin(), lhs.end(),
rhs.begin(), rhs.end());.

If any of the following conditions is satisfied, the behavior is undefined:

value_type is notLessThanComparable.
operator< does not establishtotal order.

7) Equivalent toreturnstd::lexicographical_compare_three_way(lhs.begin(), lhs.end(),
rhs.begin(), rhs.end(),
synth-three-way).

The return type is the return type ofsynth-three-way (i.e.,synth-three-way-result <value_type>).

If any of the following conditions is satisfied, the behavior is undefined:

T does not modelthree_way_comparable.
operator< is not defined for values of type (possibly const-qualified)value_type.
operator< does not establishtotal order.

The<,<=,>,>=, and!= operators aresynthesized fromoperator<=> andoperator== respectively.

(since C++20)

[edit]Parameters

lhs, rhs - multisets whose contents to compare

[edit]Return value

Operator	lhs andrhs are equal	lhs is lexicographically greater	rhs is lexicographically greater
operator==	true	false
operator!=	false	true
operator<	false	false	true
operator<=	true	false	true
operator>	false	true	false
operator>=	true	true	false
operator<=>	a value equal to0	a value greater then0	a value less than0

[edit]Complexity

1,2) Constant iflhs andrhs are of different size, otherwise linear in the size of themultiset.

3-7) Linear in the size of themultiset.

[edit]Notes

The relational operators are defined in terms ofvalue_type'soperator<.

(until C++20)

The relational operators are not defined. The rewritten candidateoperator<=> will be selected by overload resolution.

operator<=> usesvalue_type'soperator<=> if possible, orvalue_type'soperator< otherwise. Notably, if thevalue_type does not itself provideoperator<=>, but is implicitly convertible to a three-way comparable type, that conversion will be used instead ofoperator<.

(since C++20)

These non-member comparison operators do not useCompare to compare elements.

[edit]Example

Run this code

#include <cassert>#include <compare>#include <set> int main(){conststd::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&&"");}