operator==,!=,<,<=,>,>=,<=>(std::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::list

成員函式
list::list list::~list list::operator= list::assign list::assign_range (C++23)   list::get_allocator 元素訪問 list::front list::back 迭代器 list::beginlist::cbegin (C++11) list::endlist::cend (C++11) list::rbeginlist::crbegin (C++11) list::rendlist::crend (C++11) 容量 list::size list::empty list::max_size	修改器 list::clear list::insert list::insert_range (C++23) list::emplace (C++11) list::erase list::push_front list::emplace_front (C++11) list::prepend_range (C++23) list::pop_front list::push_back list::emplace_back (C++11) list::append_range (C++23) list::pop_back list::resize list::swap 操作 list::merge list::splice list::removelist::remove_if list::reverse list::unique list::sort
非成員函式
operator==operator<=> (C++20 起) swap(std::list) erase(std::list)erase_if(std::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)

 

定義於標頭檔案 <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)	(C++20 前)
template< class T, class Alloc > bool operator<( const std::list<T, Alloc>& lhs,                 const std::list<T, Alloc>& rhs );	(3)	(C++20 前)
template< class T, class Alloc > bool operator<=( const std::list<T, Alloc>& lhs,                  const std::list<T, Alloc>& rhs );	(4)	(C++20 前)
template< class T, class Alloc > bool operator>( const std::list<T, Alloc>& lhs,                 const std::list<T, Alloc>& rhs );	(5)	(C++20 前)
template< class T, class Alloc > bool operator>=( const std::list<T, Alloc>& lhs,                  const std::list<T, Alloc>& rhs );	(6)	(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)	(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>）。

如果以下條件均不滿足，則行為未定義

• T 滿足 three_way_comparable。
• 為型別（可能 const 限定的）T 的值定義了 <，並且 < 是全序關係。

<、<=、>、>= 和 != 運算子分別從 operator<=> 和 operator== 合成。

(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< 定義的。	(C++20 前)
關係運算符是根據 synth-three-way 定義的，它會盡可能使用 operator<=>，否則使用 operator<。 值得注意的是，如果元素本身不提供 operator<=>，但可以隱式轉換為三向可比較型別，則將使用該轉換而不是 operator<。	(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++ 標準。

缺陷報告	應用於	釋出時的行為	正確的行為
LWG 3431	C++20	operator<=> 未要求 T 滿足 three_way_comparable	requires