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

来自cppreference.com
< cpp‎ | container‎ | array

 
C++
 
容器库
 
std::array
 
在标头 <array> 定义
template< class T, std::size_t N >

bool operator==( const std::array<T, N>& lhs,

                 const std::array<T, N>& rhs );
 (1) (C++11 起)
(C++20 起为 constexpr)
template< class T, std::size_t N >

bool operator!=( const std::array<T, N>& lhs,

                 const std::array<T, N>& rhs );
 (2) (C++11 起)
(C++20 前)
template< class T, std::size_t N >

bool operator<( const std::array<T, N>& lhs,

                const std::array<T, N>& rhs );
 (3) (C++11 起)
(C++20 前)
template< class T, std::size_t N >

bool operator<=( const std::array<T, N>& lhs,

                 const std::array<T, N>& rhs );
 (4) (C++11 起)
(C++20 前)
template< class T, std::size_t N >

bool operator>( const std::array<T, N>& lhs,

                const std::array<T, N>& rhs );
 (5) (C++11 起)
(C++20 前)
template< class T, std::size_t N >

bool operator>=( const std::array<T, N>& lhs,

                 const std::array<T, N>& rhs );
 (6) (C++11 起)
(C++20 前)
template< class T, std::size_t N >

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

                 const std::array<T, N>& rhs );
 (7) (C++20 起)

比较两个 array 的内容。

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>）。
如果不满足以下任意条件，那么行为未定义：
  • T 实现了 three_way_comparable。
  • 为（可有 const 限定的）T 类型的值定义了 <，并且 < 是全序关系。

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

(C++20 起)

参数

lhs, rhs - 要比较内容的 array
-
为使用重载 (1,2)， T 必须满足可相等比较 (EqualityComparable) 。
-
为使用重载 (3-6)， T 必须满足可小于比较 (LessThanComparable) 。顺序关系必须建立全序。

返回值

1) 在 array 内容相等时返回 true，否则返回 false
2) 在 array 内容不相等时返回 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()。

复杂度

与 array 的大小成线性

注解

各关系运算符是基于各个元素的 operator< 定义的。

(C++20 前)

各关系运算符是基于 synth-three-way 定义的，若有可能则它会使用 operator<=>，否则使用 operator<。

要注意，如果元素类型自身并不提供 operator<=>，但可以隐式转换为可三路比较的类型，则就会用这项转换来替代 operator<。

(C++20 起)

示例

运行此代码
#include <cassert>
#include <compare>
#include <array>
 
int main()
{
    const std::array
        a{1, 2, 3},
        b{1, 2, 3},
        c{7, 8, 9};
 
    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 需要
来自“https://zh.cppreference.com/mwiki/index.php?title=cpp/container/array/operator_cmp&oldid=65084”