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

(1)`<tuple>`
template< class... TTypes, class... UTypes > bool operator==( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );	(начиная с C++11)	(constexpr начиная с C++14) (2)
template< class... TTypes, class... UTypes > bool operator!=( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );	(начиная с C++11)	(constexpr начиная с C++14) (до C++20) (3)
template< class... TTypes, class... UTypes > bool operator<( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );	(начиная с C++11)	(constexpr начиная с C++14) (до C++20) (4)
template< class... TTypes, class... UTypes > bool operator<=( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );	(начиная с C++11)	(constexpr начиная с C++14) (до C++20) (5)
template< class... TTypes, class... UTypes > bool operator>( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );	(начиная с C++11)	(constexpr начиная с C++14) (до C++20) (6)
template< class... TTypes, class... UTypes > bool operator>=( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );	(начиная с C++11)	(constexpr начиная с C++14) (до C++20) (7)
template< class... TTypes, class... UTypes > constexpr std::common_comparison_category_t< synth-three-way-result<TTypes, Elems>...> operator<=>( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );	(начиная с C++20)	(8)
template< class... TTypes, tuple-like UTuple > constexpr bool operator==( const tuple<TTypes...>& lhs, const UTuple& rhs );	(начиная с C++23)	(9)
template< class... TTypes, tuple-like UTuple > constexpr std::common_comparison_category_t< synth-three-way-result<TTypes, /* Elems */>...> operator<=>( const tuple<TTypes...>& lhs, const UTuple& rhs );	(начиная с C++23)	1,2)

Сравнивает каждый элемент кортежа с соответствующим элементом кортежа lhs с помощью rhs.operator==1)

Возвращает , если все пары соответствующих элементов равны.true2)

Возвращает .!(lhs == rhs) Если

не равно sizeof...(TTypes) или sizeof...(UTypes) не является корректным выражением для любого std::get(lhs) == std::get(rhs) в i, программа считается некорректной.[0, sizeof...(Types)) Если тип и категория значения

не соответствуют требованиям std::get(lhs) == std::get(rhs)BooleanTestable для любого в i, поведение не определено. [0, sizeof...(Types))(до C++26)

Эта перегрузка участвует в разрешении перегрузки только если

равно sizeof...(TTypes), sizeof...(UTypes) является корректным выражением и std::get(lhs) == std::get(rhs) удовлетворяют decltype(std::get(lhs) == std::get(rhs))boolean-testable для каждого в i. [0, sizeof...(Types))(начиная с C++26)

3-6)

Сравнивает и lhs лексикографически с помощью rhs, то есть сравнивает первые элементы, если они эквивалентны, сравнивает вторые элементы, если они эквивалентны, сравнивает третьи элементы и так далее.operator<3)

Для пустых кортежей возвращает . Для непустых кортежей эффект эквивалентенfalse4)

if (std::get<0>(lhs) < std::get<0>(rhs)) return true; if (std::get<0>(rhs) < std::get<0>(lhs)) return false; if (std::get<1>(lhs) < std::get<1>(rhs)) return true; if (std::get<1>(rhs) < std::get<1>(lhs)) return false; ... return std::get<N - 1>(lhs) < std::get<N - 1>(rhs);

Возвращает .!(rhs < lhs)5)

Возвращает .rhs < lhs6)

Возвращает .!(lhs < rhs) Если

не равно sizeof...(TTypes), или любое из выражений сравнения, указанных в выражениях, эквивалентных этим операторам, не является корректным выражением, программа считается некорректной.sizeof...(UTypes) Если тип и категория значения любого из выражений сравнения, указанных в выражениях, эквивалентных этим операторам, не соответствуют требованиям

BooleanTestable, поведение не определено.7)

Сравнивает и lhs лексикографически с помощью rhssynth-three-way, то есть сравнивает первые элементы, если они эквивалентны, сравнивает вторые элементы, если они эквивалентны, сравнивает третьи элементы и так далее.Для пустых кортежей возвращает

std::strong_ordering::equal.Для непустых кортежей эффект эквивалентен
synth-three-way

if (auto c = synth-three-way(std::get<0>(lhs), std::get<0>(rhs)); c != 0) return c;
if (auto c = synth-three-way(std::get<1>(lhs), std::get<1>(rhs)); c != 0) return c;
...
return 8)(std::get<N - 1>(lhs), std::get<N - 1>(rhs));

То же, что и (1), за исключением того, что является объектом rhs, а количество элементов tuple-like определяется с помощью rhs. Эту перегрузку можно найти только через std::tuple_size_v<UTuple>поиск, зависящий от аргументов.9)

То же, что и (7), за исключением того, что является объектом rhs. tuple-like обозначает пакет типов /* Elems */ для каждого std::tuple_element_t<i, UTuple> в i в порядке возрастания. Эту перегрузку можно найти только через [0, std::tuple_size_v<UTuple>)поиск, зависящий от аргументов.Все операторы сравнения являются короткозамкнутыми; они не обращаются к элементам кортежа за пределами того, что необходимо для определения результата сравнения.

Операторы

, <, <=, >, >= и != синтезируются из operator<=> и operator== соответственно.

(начиная с C++20)

Параметры

lhs, rhs

-

кортежи для сравнения

Возвращаемое значение

1,8) true если std :: get ( lhs ) == std :: get ( rhs ) для всех i в диапазоне

0

sizeof... ( Types )

, иначе false . Для двух пустых кортежей возвращает true .

2) ! ( lhs == rhs )

3) true если первый неэквивалентный элемент в lhs меньше соответствующего элемента в rhs , false если первый неэквивалентный элемент в rhs меньше соответствующего элемента в lhs или если неэквивалентные элементы отсутствуют. Для двух пустых кортежей возвращает false .

4) ! ( rhs < lhs )

5) rhs < lhs

6) ! ( lhs < rhs )

7,9) Отношение между первой парой неэквивалентных элементов, если таковая имеется, std::strong_ordering::equal в противном случае. Для двух пустых кортежей возвращает std::strong_ordering::equal .

Примечания

Операторы сравнения определяются через operator < каждого элемента.

(до C++20)

Операторы сравнения определяются через synth-three-way , который использует operator <=> если возможно, или operator < в противном случае.

Важно отметить, что если тип элемента сам не предоставляет operator <=> , но неявно преобразуется в тип с трёхсторонним сравнением, это преобразование будет использовано вместо operator < .

(начиная с C++20)

Макрос тестирования возможностей	Значение	Стандарт	Функция
`__cpp_lib_constrained_equality`	`202403L`	(C++26)	Ограниченный operator == для std::tuple

Пример

Поскольку operator < определён для кортежей, контейнеры кортежей можно сортировать.

Запустить этот код

#include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
int main()
{
    std::vector<std::tuple<int, std::string, float>> v
    {
        {2, "baz", -0.1},
        {2, "bar", 3.14},
        {1, "foo", 10.1},
        {2, "baz", -1.1},
    };
    std::sort(v.begin(), v.end());
    for (const auto& p: v)
        std::cout << "{ " << get<0>(p)
                  << ", " << get<1>(p)
                  << ", " << get<2>(p)
                  << " }\n";
}

Вывод:

{ 1, foo, 10.1 }
{ 2, bar, 3.14 }
{ 2, baz, -1.1 }
{ 2, baz, -0.1 }

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены ретроактивно к ранее опубликованным стандартам C++.

DR	Applied to	Behavior as published	Correct behavior
LWG 2114 ( P2167R3 )	C++11	отсутствовали предусловия типов для булевых операций	добавлены

(удалено в C++20) (удалено в C++20) (удалено в C++20) (удалено в C++20) (удалено в C++20) (C++20)

лексикографически сравнивает значения в


          pair

(шаблон функции)

Поддержка компиляторов
Автономные и размещённые реализации
Язык
Стандартная библиотека
Заголовки стандартной библиотеки
Именованные требования
Макросы проверки возможностей (C++20)
Библиотека поддержки языка
Библиотека концепций (C++20)
Библиотека диагностики
Библиотека управления памятью
Библиотека метапрограммирования (C++11)
Библиотека общих утилит
Библиотека контейнеров
Библиотека итераторов
Библиотека диапазонов (C++20)
Библиотека алгоритмов
Библиотека строк
Библиотека обработки текста
Библиотека численных операций
Библиотека даты и времени
Библиотека ввода/вывода
Библиотека файловых систем (C++17)
Библиотека поддержки конкурентности (C++11)
Библиотека управления выполнением (C++26)
Технические спецификации
Индекс символов
Внешние библиотеки

tuple::operator=
tuple::swap
Функции, не являющиеся элементами
make_tuple
tie
forward_as_tuple
tuple_cat
operator==
operator!=
operatoroperator=<operator<operator=>operator>=(до C++20)<(до C++20)> (до C++20)(до C++20)(до C++20)(до C++20)(C++20)swap
(std::tuple)get
(std::tuple)Вспомогательные концепции
(C++23)
`tuple-like` Вспомогательные классы
tuple_size
std::tuple<tuple_element>
std::tuple<uses_allocator>
std::tuple<basic_common_reference>
std::tuple<(C++23)> common_type
std::tuple<(C++23)> formatter
std::tuple<(C++23)> ignore
Дедис-гайды
(C++17)Определён в заголовочном файле

ru.cppreference.net

Namespaces

Variants