命名空间
变体
操作

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

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

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

                 const std::vector<T, Alloc>& rhs );
(1) (从 C++20 开始为 constexpr)
template< class T, class Alloc >

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

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

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

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

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

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

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

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

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

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

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

                 const std::vector<T, Alloc>& rhs );
(7) (从 C++20 开始)

比较两个 vector 的内容。

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

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

(从 C++20 开始)

内容

[编辑] 参数

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

[编辑] 返回值

1) 如果 vector 的内容相等,则为 true,否则为 false
2) 如果 vector 的内容不相等,则为 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 大小不同,则为常数;否则为 vector 大小的线性。
3-7)vector 大小的线性。

[编辑] 注释

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

(直到 C++20)

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

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

(从 C++20 开始)

[编辑] 示例

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