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

 

C++

编译器支持

独立和托管

语言

标准库

标准库头文件

命名需求

特性测试宏 (C++20)

语言支持库

概念库 (C++20)

元编程库 (C++11)

诊断库

通用实用程序库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

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

并发支持库 (C++11)

执行支持库 (C++26)

技术规范

符号索引

外部库

 

容器库

序列

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

deque

forward_list (C++11)

list

关联

set

multiset

map

multimap

无序关联

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

适配器

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

视图

span (C++20)

mdspan (C++23)

表格

迭代器失效

成员函数表

非成员函数表

 

std::array

成员类型
成员函数
元素访问 array::at array::operator[]    array::front array::back array::data 操作 array::fill array::swap	迭代器 array::beginarray::cbegin array::endarray::cend array::rbeginarray::crbegin    array::rendarray::crend	容量 array::empty array::size array::max_size
非成员函数
operator==operator<=> (C++20) get(std::array) swap(std::array) to_array (C++20)	operator|=operator<operator>operator<=operator>= (直到 C++20)(直到 C++20)(直到 C++20)(直到 C++20)(直到 C++20)
辅助类
tuple_size<std::array>
tuple_element<std::array>
推导指南 (C++17)

 

定义在头文件 <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) true 如果 lhs 的内容在字典序上大于rhs 的内容，否则为 false。

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