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

 

C++

编译器支持

独立和宿主式

语言

标准库

标准库头文件

命名要求

特性测试宏 (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::vector

成员类型
成员函数
vector::vector vector::~vector vector::operator= vector::assign vector::assign_range (C++23)   vector::get_allocator 元素访问 vector::operator[] vector::at vector::data vector::front vector::back 迭代器 vector::beginvector::cbegin (C++11) vector::endvector::cend (C++11) vector::rbeginvector::crbegin (C++11) vector::rendvector::crend (C++11)	容量 vector::empty vector::size vector::max_size vector::reserve vector::capacity vector::shrink_to_fit (DR*) 修改器 vector::clear vector::erase vector::insert vector::insert_range (C++23) vector::append_range (C++23) vector::emplace (C++11) vector::emplace_back (C++11) vector::push_back vector::pop_back vector::resize vector::swap
非成员函数
operator==operator<=> (C++20) swap(std::vector) erase(std::vector)erase_if(std::vector) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (C++20 前)(C++20 前)(C++20 前)(C++20 前)(C++20 前)
推导指引(C++17)

 

定义于头文件 <vector>
template< class T, class Alloc > bool operator==( const std::vector<T, Alloc>& lhs,                  const std::vector<T, Alloc>& rhs );	(1)	(constexpr since C++20)
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) 检查 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	-	要比较内容的 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) 如果 lhs 的内容在字典序上大于或等于 rhs 的内容，则为 true，否则为 false。

7) 若存在非等价元素对，则为 lhs 和 rhs 中首个非等价元素对的相对顺序；否则为 lhs.size() <=> rhs.size()。

复杂度

1,2) 若 lhs 和 rhs 大小不同则为常数，否则与 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	要求