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

 

C++

编译器支持

独立和托管

语言

标准库

标准库头文件

命名需求

功能测试宏 (C++20)

语言支持库

概念库 (C++20)

元编程库 (C++11)

诊断库

通用实用程序库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

正则表达式库 (C++11)

并发支持库 (C++11)

执行支持库 (C++26)

技术规范

符号索引

外部库

 

容器库

序列

数组 (C++11)

向量

vector<bool>

inplace_vector (C++26)

双端队列

前向列表 (C++11)

列表

关联

集

多重集

映射

多重映射

无序关联

无序集 (C++11)

无序多重集 (C++11)

无序映射 (C++11)

无序多重映射 (C++11)

适配器

堆栈

队列

优先级队列

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

视图

跨度 (C++20)

mdspan (C++23)

表格

迭代器失效

成员函数表

非成员函数表

 

std::multimap

成员函数

multimap::multimap multimap::~multimap        multimap::operator= multimap::get_allocator

迭代器 multimap::beginmultimap::cbegin (C++11) multimap::endmultimap::cend (C++11) multimap::rbeginmultimap::crbegin (C++11)    multimap::rendmultimap::crend (C++11) 容量 multimap::size multimap::max_size multimap::empty 观察者 multimap::key_comp multimap::value_comp 修改器 multimap::clear multimap::insert multimap::erase multimap::swap multimap::merge (C++17) multimap::insert_range (C++23) multimap::emplace (C++11) multimap::emplace_hint (C++11) multimap::extract (C++17) 查找 multimap::count multimap::find multimap::contains (C++20) multimap::equal_range multimap::lower_bound multimap::upper_bound

非成员函数

operator==operator<=> (C++20) std::swap(std::multimap) erase_if(std::multimap) (C++20)   operator!=operator<operator>operator<=operator>= (直到 C++20)(直到 C++20)(直到 C++20)(直到 C++20)(直到 C++20)

推断指南(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)
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) 如果 multimap 的内容相等，则为 true，否则为 false。

2) 如果 multimap 的内容不相等，则为 true，否则为 false。

3) 如果 lhs 的内容在字典顺序上小于 rhs 的内容，则为 true，否则为 false。

4) 如果 lhs 的内容在字典顺序上小于或等于 rhs 的内容，则为 true，否则为 false。

5) 如果 lhs 的内容在字典顺序上大于 rhs 的内容，则为 true，否则为 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	要求