Namespaces
Variants

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

    来自 zh.cppreference.net
     
    C++
     
    工具库
    通用工具
    关系运算符 (C++20 弃用)
    整数比较函数
    (C++20)(C++20)(C++20)    
    (C++20)
    交换 与 类型操作
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    常用词汇类型
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    std::pair
     
    定义于头文件 <utility> 
    template< class T1, class T2, class U1, class U2 >
bool operator==( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(1) (C++14 前) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator==( const std::pair<T1, T2>& lhs,
                           const std::pair<U1, U2>& rhs );
    		(C++14 起) 
    template< class T1, class T2, class U1, class U2 >
bool operator!=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(2) (C++14 前) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator!=( const std::pair<T1, T2>& lhs,
                           const std::pair<U1, U2>& rhs );
    		(C++14 起)
    (C++20 前)    		 
    template< class T1, class T2, class U1, class U2 >
bool operator<( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(3) (C++14 前) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator<( const std::pair<T1, T2>& lhs,
                          const std::pair<U1, U2>& rhs );
    		(C++14 起)
    (C++20 前)    		 
    template< class T1, class T2, class U1, class U2 >
bool operator<=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(4) (C++14 前) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator<=( const std::pair<T1, T2>& lhs,
                           const std::pair<U1, U2>& rhs );
    		(C++14 起)
    (C++20 前)    		 
    template< class T1, class T2, class U1, class U2 >
bool operator>( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(5) (C++14 前) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator>( const std::pair<T1, T2>& lhs,
                          const std::pair<U1, U2>& rhs );
    		(C++14 起)
    (C++20 前)    		 
    template< class T1, class T2, class U1, class U2 >
bool operator>=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(6) (C++14 前) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator>=( const std::pair<T1, T2>& lhs,
                           const std::pair<U1, U2>& rhs );
    		(C++14 起)
    (C++20 前)    		 
    template< class T1, class T2, class U1, class U2 >
constexpr std::common_comparison_category_t<synth-three-way-result<T1, U1>,
                                            synth-three-way-result<T2, U2>>
    operator<=>( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(7) (C++20 起)
    1,2) 测试 lhs 和 rhs 的两个元素是否都相等，即比较 lhs.first 与 rhs.first 以及 lhs.second 与 rhs.second。

    如果 lhs.first == rhs.first 或 lhs.second == rhs.second 的类型和值类别不满足 BooleanTestable 要求，则行为未定义。

    		(C++26 前)

    仅当 decltype(lhs.first == rhs.first) 和 decltype(lhs.second == rhs.second) 都满足 boolean-testable 时，此重载才参与重载决议。

    		(C++26 起)
    3-6) 按字典序通过 lhs 比较 rhs 和 operator<，即先比较第一个元素，仅当它们相等时才比较第二个元素。如果 lhs.first < rhs.first、rhs.first < lhs.first 或 lhs.second < rhs.second 中任何一个的类型和值类别不满足 BooleanTestable 要求，则行为未定义。
    7) 按字典序通过 lhssynth-three-wayrhs 比较 和 ，即先比较第一个元素，仅当它们相等时才比较第二个元素。synth-three-way-result 是 synth-three-way 的返回类型。

    <、<=、>、>= 和 != 运算符分别通过 和 operator<=>合成operator==而来。

    		(C++20 起)

    参数

    lhs, rhs - 待比较的配对参数

    返回值

    1) true 当且仅当 lhs. first == rhs. first 且 lhs. second == rhs. second ，否则返回 false 。
    2) ! ( lhs == rhs )
    3) 若 lhs. first < rhs. first ，则返回 true 。否则，若 rhs. first < lhs. first ，则返回 false 。否则，若 lhs. second < rhs. second ，则返回 true 。否则返回 false 。
    4) ! ( rhs < lhs )
    5) rhs < lhs
    6) ! ( lhs < rhs )
    7) synth-three-way ( lhs. first , rhs. first ) 若其不等于 ​ 0 ​ ，否则返回 synth-three-way ( lhs. second , rhs. second ) 。

    注释

    关系运算符是通过每个元素的 operator < 来定义的。

    		(C++20 前)

    关系运算符通过 synth-three-way 定义，该机制优先使用 operator <=> ，若不可用则回退至 operator < 。

    值得注意的是，若元素类型本身未提供 operator <=> ，但可隐式转换为支持三路比较的类型，则将使用该转换而非 operator < 。

    		(C++20 起)
    功能测试 宏 值 标准 功能特性
    __cpp_lib_constrained_equality 202403L (C++26) 约束式 operator == 用于 std::pair

    示例

    由于为 operator < 定义了针对 pair 的运算符，因此可以对包含 pair 的容器进行排序。

    运行此代码 
    #include <algorithm>
#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
int main()
{
    std::vector<std::pair<int, std::string>> v = {{2, "baz"}, {2, "bar"}, {1, "foo"}};
    std::sort(v.begin(), v.end());
    for (auto p : v)
        std::cout << '{' << p.first << ", " << std::quoted(p.second) << "}\n";
}

    输出： 

    {1, "foo"}
{2, "bar"}
{2, "baz"}

    缺陷报告

    以下行为变更缺陷报告被追溯应用于先前发布的 C++ 标准。

    DR 适用版本 发布行为 正确行为
    LWG 296 C++98 除 == 和 < 外的运算符描述缺失 已补充
    LWG 2114
    ( P2167R3 )     		C++98 布尔运算的类型前置条件缺失 已补充
    LWG 3865 C++98 比较运算符仅接受相同类型的 pair 接受不同类型的 pair

    参阅

    (C++20 中移除)(C++20 中移除)(C++20 中移除)(C++20 中移除)(C++20 中移除)(C++20)
    		 按字典序比较元组中的值
    (函数模板)