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

 

C++

编译器支持

自由（freestanding）与宿主（hosted）

语言

标准库

标准库头文件

具名要求

特性测试宏 (C++20)

语言支持库

概念库 (C++20)

诊断库

内存管理库

元编程库 (C++11)

通用工具库

容器库

迭代器库

范围库 (C++20)

算法库

字符串库

文本处理库

数值库

日期和时间库

输入/输出库

文件系统库 (C++17)

并发支持库 (C++11)

执行控制库 (C++26)

技术规范

符号索引

外部库

 

容器库

序列

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (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::forward_list

成员函数
forward_list::forward_list forward_list::~forward_list forward_list::operator= forward_list::assign forward_list::assign_range (C++23)   forward_list::get_allocator 元素访问 forward_list::front 迭代器 forward_list::before_beginforward_list::cbefore_begin forward_list::beginforward_list::cbegin forward_list::endforward_list::cend 容量 forward_list::empty forward_list::max_size	修改器 forward_list::clear forward_list::emplace_front forward_list::push_front forward_list::insert_after forward_list::emplace_after forward_list::erase_after forward_list::insert_range_after (C++23) forward_list::prepend_range (C++23) forward_list::pop_front forward_list::resize forward_list::swap 操作 forward_list::merge forward_list::splice_after forward_list::removeforward_list::remove_if forward_list::reverse forward_list::unique forward_list::sort
非成员函数
operator==operator<=> (C++20 起) swap(std::forward_list) erase(std::forward_list)erase_if(std::forward_list) (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)

 

在头文件 <forward_list> 中定义
template< class T, class Alloc > bool operator==( const std::forward_list<T, Alloc>& lhs,                  const std::forward_list<T, Alloc>& rhs );	(1)	(C++11 起)
template< class T, class Alloc > bool operator!=( const std::forward_list<T, Alloc>& lhs,                  const std::forward_list<T, Alloc>& rhs );	(2)	(C++11 起) (C++20 前)
template< class T, class Alloc > bool operator<( const std::forward_list<T, Alloc>& lhs,                 const std::forward_list<T, Alloc>& rhs );	(3)	(C++11 起) (C++20 前)
template< class T, class Alloc > bool operator<=( const std::forward_list<T, Alloc>& lhs,                  const std::forward_list<T, Alloc>& rhs );	(4)	(C++11 起) (C++20 前)
template< class T, class Alloc > bool operator>( const std::forward_list<T, Alloc>& lhs,                 const std::forward_list<T, Alloc>& rhs );	(5)	(C++11 起) (C++20 前)
template< class T, class Alloc > bool operator>=( const std::forward_list<T, Alloc>& lhs,                  const std::forward_list<T, Alloc>& rhs );	(6)	(C++11 起) (C++20 前)
template< class T, class Alloc > synth-three-way-result<T>     operator<=>( const std::forward_list<T, Alloc>& lhs,                  const std::forward_list<T, Alloc>& rhs );	(7)	(C++20 起)

比较两个 forward_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>）。

如果以下条件均不满足，则行为未定义

• T 满足 three_way_comparable。
• 为类型（可能 const 限定的）T 的值定义了 <，并且 < 是全序关系。

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

(C++20 起)

参数

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

返回值

1) 如果 forward_list 的内容相等则为 true，否则为 false。

2) 如果 forward_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()。

复杂度

与 forward_list 的大小成线性关系。

注解

关系运算符是根据元素类型的 operator< 定义的。	(C++20 前)
关系运算符是根据 synth-three-way 定义的，它尽可能使用 operator<=>，否则使用 operator<。 值得注意的是，如果元素本身不提供 operator<=>，但可以隐式转换为三向可比较类型，则将使用该转换而不是 operator<。	(C++20 起)

示例

运行此代码

#include <cassert>
#include <compare>
#include <forward_list>
 
int main()
{
    const std::forward_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++ 标准。

缺陷报告	应用于	发布时的行为	正确的行为
LWG 3431	C++20	operator<=> 未要求 T 满足 three_way_comparable	要求