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

Определено в заголовке `<tuple>`
	(1)
template< class... TTypes, class... UTypes > bool operator==( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );		(с C++11) (до C++14)
template< class... TTypes, class... UTypes > constexpr bool operator==( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );		(с C++14)
	(2)
template< class... TTypes, class... UTypes > bool operator!=( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );		(с C++11) (до C++14)
template< class... TTypes, class... UTypes > constexpr bool operator!=( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );		(с C++14) (до C++20)
	(3)
template< class... TTypes, class... UTypes > bool operator<( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );		(с C++11) (до C++14)
template< class... TTypes, class... UTypes > constexpr bool operator<( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );		(с C++14) (до C++20)
	(4)
template< class... TTypes, class... UTypes > bool operator<=( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );		(с C++11) (до C++14)
template< class... TTypes, class... UTypes > constexpr bool operator<=( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );		(с C++14) (до C++20)
	(5)
template< class... TTypes, class... UTypes > bool operator>( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );		(с C++11) (до C++14)
template< class... TTypes, class... UTypes > constexpr bool operator>( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );		(с C++14) (до C++20)
	(6)
template< class... TTypes, class... UTypes > bool operator>=( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );		(с C++11) (до C++14)
template< class... TTypes, class... UTypes > constexpr bool operator>=( const std::tuple<TTypes...>& lhs, const std::tuple<UTypes...>& rhs );		(с C++14) (до C++20)
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 );	(7)	(с C++20)
template< class... TTypes, tuple-like UTuple > constexpr bool operator==( const tuple<TTypes...>& lhs, const UTuple& rhs );	(8)	(с C++23)
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 );	(9)	(с C++23)

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

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

2) Возвращает !(lhs == rhs).

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

Если decltype(std::get(lhs) == std::get(rhs)) не моделирует boolean-testable для любого i в [0, sizeof...(Types)), поведение не определено.

(с C++23)

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

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

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);

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

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

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

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

7) Сравнивает lhs и rhs лексикографически по synth-three-way, т.е. сравнивает первые элементы, если они эквивалентны, сравнивает вторые элементы, если они эквивалентны, сравнивает третьи элементы и так далее.

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

 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 synth-three-way(std::get<N - 1>(lhs), std::get<N - 1>(rhs));

8) То же, что (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>) в порядке возрастания. Этот перегруз можно найти только через поиск аргументов по зависимости.

Все операторы сравнения являются краткими; они не обращаются к элементам кортежа, выходящим за пределы необходимых для определения результата сравнения.

Операторы <, <=, >, >=, и != генерируются соответственно из оператора<=> и оператора==.

(с 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.

Пример

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

#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 << "{ " << std::get<0>(p)
                  << ", " << std::get<1>(p)
                  << ", " << std::get<2>(p)
                  << " }\n";
}

Вывод:

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

См. также

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/w/cpp/utility/tuple/operator_cmp