命名空间
变体
操作

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

来自 cppreference.com
< cpp‎ | container‎ | set
 
 
 
 
定义在头文件 <set>
template< class Key, class Compare, class Alloc >

bool operator==( const std::set<Key, Compare, Alloc>& lhs,

                 const std::set<Key, Compare, Alloc>& rhs );
(1)
template< class Key, class Compare, class Alloc >

bool operator!=( const std::set<Key, Compare, Alloc>& lhs,

                 const std::set<Key, Compare, Alloc>& rhs );
(2) (直到 C++20)
template< class Key, class Compare, class Alloc >

bool operator<( const std::set<Key, Compare, Alloc>& lhs,

                const std::set<Key, Compare, Alloc>& rhs );
(3) (直到 C++20)
template< class Key, class Compare, class Alloc >

bool operator<=( const std::set<Key, Compare, Alloc>& lhs,

                 const std::set<Key, Compare, Alloc>& rhs );
(4) (直到 C++20)
template< class Key, class Compare, class Alloc >

bool operator>( const std::set<Key, Compare, Alloc>& lhs,

                const std::set<Key, Compare, Alloc>& rhs );
(5) (直到 C++20)
template< class Key, class Compare, class Alloc >

bool operator>=( const std::set<Key, Compare, Alloc>& lhs,

                 const std::set<Key, Compare, Alloc>& rhs );
(6) (直到 C++20)
template< class Key, class Compare, class Alloc >

synth-three-way-result<T>
    operator<=>( const std::set<Key, Compare, Alloc>& lhs,

                 const std::set<Key, Compare, Alloc>& rhs );
(7) (从 C++20 开始)

比较两个 set 的内容。

1,2) 检查 lhsrhs 的内容是否相等,也就是说,它们具有相同数量的元素,并且 lhs 中的每个元素都与 rhs 中相同位置的元素相等。
3-6) 按字典顺序比较 lhsrhs 的内容。比较通过等效于 std::lexicographical_compare 的函数执行。此比较忽略了 set 的排序 Compare
7) 按字典顺序比较 lhsrhs 的内容。比较的执行方式类似于调用 std::lexicographical_compare_three_way(lhs.begin(), lhs.end(),
                                       rhs.begin(), rhs.end(), synth-three-way)
.此比较忽略了 set 的排序 Compare
返回类型是 synth-three-way 的返回类型(即,synth-three-way-result <T>)。
如果不满足以下任何条件,则行为未定义
  • T 符合 three_way_comparable 的要求。
  • < 为类型(可能经过常量限定)的 T 值定义,并且 < 是一个全序关系。

<<=>>=!= 运算符分别从 operator<=>operator== 合成。

(从 C++20 开始)

内容

[编辑] 参数

lhs, rhs - 要比较其内容的 set
-
Key 必须满足 EqualityComparable 的要求,以便使用重载(1,2)。

[编辑] 返回值

1) 如果 set 的内容相等,则为 true,否则为 false
2) 如果 set 的内容不相等,则为 true,否则为 false
3) 如果 lhs 的内容在字典上小于 rhs 的内容,则为 true,否则为 false
4) 如果 lhs 的内容在字典上小于等于 rhs 的内容,则为 true,否则为 false
5) 如果 lhs 的内容在字典上大于 rhs 的内容,则为 true,否则为 false
6) true 如果 lhs 的内容在字典序上大于或等于 rhs 的内容,否则为 false
7) 如果 lhsrhs 中存在不相同的元素,则返回第一个不相同元素对的相对顺序;否则返回 lhs.size() <=> rhs.size()

[编辑] 复杂度

1,2) 如果 lhsrhs 的大小不同,则为常数时间;否则为 set 大小的线性时间。
3-7) set 大小的线性时间。

[编辑] 说明

关系运算符根据元素类型的 operator< 定义。

(直到 C++20)

关系运算符根据 synth-three-way 定义,如果可能,它使用 operator<=>,否则使用 operator<

值得注意的是,如果元素本身没有提供 operator<=>,但可以隐式转换为三路比较类型,则将使用该转换,而不是 operator<

(从 C++20 开始)

[编辑] 示例

#include <cassert>
#include <compare>
#include <set>
 
int main()
{
    const std::set
        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
需要