operator==,!=,<,<=,>,>=,<=>(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 );	(1)		(начиная с 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 );	(2)		(начиная с 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 );	(3)		(начиная с 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 );	(4)		(начиная с 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 );	(5)		(начиная с 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 );	(6)		(начиная с 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) Сравнивает lhs и rhs лексикографически с помощью synth-three-way, то есть сравнивает первые элементы и, только если они эквивалентны, сравнивает вторые элементы. 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<, контейнеры пар можно сортировать.

#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` разных типов

См. также

operator==operator!=operator<operator<=operator>operator>=operator<=>

(удалён в C++20)(удалён в C++20)(удалён в C++20)(удалён в C++20)(удалён в C++20)(C++20)

лексикографически сравнивает значения в кортеже
(шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/utility/pair/operator_cmp