命名空间
变体
操作

`operator==,!=,<,<=,>,>=,<=> (std::list)`

来自 cppreference.cn
< cpp‎ | container‎ | list

[编辑模板]
 
C++
 
容器库
 
std::list
成员函数
非成员函数
operator==operator<=>
(C++20)
(C++20)(C++20)
operator!=operator<operator>operator<=operator>=
(until C++20)(until C++20)(until C++20)(until C++20)(until C++20)
推导指引(C++17)
 
定义于头文件 <list>
template< class T, class Alloc >

bool operator==( const std::list<T, Alloc>& lhs,

                 const std::list<T, Alloc>& rhs );
 (1)
template< class T, class Alloc >

bool operator!=( const std::list<T, Alloc>& lhs,

                 const std::list<T, Alloc>& rhs );
 (2) (until C++20)
template< class T, class Alloc >

bool operator<( const std::list<T, Alloc>& lhs,

                const std::list<T, Alloc>& rhs );
 (3) (until C++20)
template< class T, class Alloc >

bool operator<=( const std::list<T, Alloc>& lhs,

                 const std::list<T, Alloc>& rhs );
 (4) (until C++20)
template< class T, class Alloc >

bool operator>( const std::list<T, Alloc>& lhs,

                const std::list<T, Alloc>& rhs );
 (5) (until C++20)
template< class T, class Alloc >

bool operator>=( const std::list<T, Alloc>& lhs,

                 const std::list<T, Alloc>& rhs );
 (6) (until C++20)
template< class T, class Alloc >

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

                 const std::list<T, Alloc>& rhs );
 (7) (since C++20)

比较两个 list 的内容。

1,2) 检查 lhs 和 rhs 的内容是否相等，即它们拥有相同数量的元素，且 lhs 中的每个元素与 rhs 中相同位置的元素比较均相等。
3-6) 字典序比较 lhs 和 rhs 的内容。比较通过等价于 std::lexicographical_compare 的函数进行。
7) 字典序比较 lhs 和 rhs 的内容。比较如同调用 std::lexicographical_compare_three_way(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), synth-three-way) 一样进行。
返回类型是 synth-three-way 的返回类型（即 synth-three-way-result）。
如果不满足下列条件之一，则行为未定义
  • T 建模 three_way_comparable。
  • 为类型 T (可能为 const 限定的) 的值定义了 <，且 < 是全序关系。

<、<=、>、>= 和 != 运算符分别从 operator<=> 和 operator== 合成而来。

 (since C++20)

内容

[编辑] 参数

lhs, rhs - 要比较内容的 list
-
为了使用重载 (1,2)，T 必须满足 EqualityComparable 的要求。
-
为了使用重载 (3-6)，T 必须满足 LessThanComparable 的要求。排序关系必须建立全序。

[编辑] 返回值

1) 如果 list 的内容相等，则为 true，否则为 false。
2) 如果 list 的内容不相等，则为 true，否则为 false。
3) 如果 lhs 的内容字典序上 *小于* rhs 的内容，则为 true，否则为 false。
4) 如果 lhs 的内容字典序上 *小于或等于* rhs 的内容，则为 true，否则为 false。
5) 如果 lhs 的内容字典序上 *大于* rhs 的内容，则为 true，否则为 false。
6) 如果 lhs 的内容字典序上 *大于或等于* rhs 的内容，则为 true，否则为 false。
7) 如果存在不相等的元素对，则为 lhs 和 rhs 中第一对不相等元素的相对顺序，否则为 lhs.size() <=> rhs.size()。

[编辑] 复杂度

1,2) 如果 lhs 和 rhs 大小不同，则为常数时间，否则与 list 的大小呈线性关系。
3-7) 与 list 的大小呈线性关系。

[编辑] 注释

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

 (until C++20)

关系运算符根据 synth-three-way 定义，它在可能的情况下使用 operator<=>，否则使用 operator<。

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

 (since C++20)

[编辑] 示例

运行此代码
#include <cassert>
#include <compare>
#include <list>
 
int main()
{
    const std::list
        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		 需要
取自“https://cppreference.cn/mwiki/index.php?title=cpp/container/list/operator_cmp&oldid=161909”