Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::multimap
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:: multimap < Key, T, Compare, Alloc > & lhs,

const std:: multimap < Key, T, Compare, Alloc > & rhs ) ;
(1) (C++26 起为 constexpr)
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 >

/* 见下文 */
operator <=> ( const std:: multimap < Key, T, Compare, Alloc > & lhs,

const std:: multimap < Key, T, Compare, Alloc > & rhs ) ;
(7) (C++20 起)
(C++26 起为 constexpr)

比较两个 multimap 的内容。

设 value_type 为 multimap 的值类型（即 typename multimap :: 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 ( ) ) ; 。
若满足以下任意条件，则行为未定义：
  • value_type 不满足 可小于比较 要求。
  • operator < 未建立 全序关系 。
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 > ）。
若满足以下任一条件，则行为未定义：

< 、 <= 、 > 、 >= 和 != 运算符分别由 operator <=> 和 operator == 自动合成。

(since C++20)

目录

参数

lhs, rhs - 待比较内容的 multimap 容器

返回值

运算符 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 大小不同时为常数复杂度，否则与 multimap 的大小成线性关系。
3-7) 与 multimap 的大小成线性关系。

注释

关系运算符通过 value_type 的 operator < 定义。

(C++20 前)

未定义关系运算符。重写候选 operator <=> 将通过重载决议被选择。

operator <=> 优先使用 value_type 的 operator <=> ，否则回退至 value_type 的 operator < 。特别地，若 value_type 本身未提供 operator <=> ，但可隐式转换为支持三路比较的类型，则将使用该转换而非 operator < 。

(C++20 起)

这些非成员比较运算符不使用 Compare 来比较元素。

示例

运行此代码 
#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
    (""
        "比较相等的容器：" &&
        (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++标准。

缺陷报告 应用于 发布时的行为 正确行为
LWG 3431 C++20 operator <=> 未要求 T
建模 three_way_comparable 		要求