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

From cppreference.net

(Примечание: В данном фрагменте HTML отсутствует текстовое содержимое для перевода - присутствуют только HTML-теги и атрибуты, которые согласно инструкциям не подлежат переводу)

Определено в заголовочном файле `<tuple>`
template < class ... TTypes , class ... UTypes > bool operator == ( const std:: tuple < TTypes... > & lhs, const std:: tuple < UTypes... > & rhs ) ;	(1)	(начиная с C++11) (constexpr начиная с C++14)
template < class ... TTypes , class ... UTypes > bool operator ! = ( const std:: tuple < TTypes... > & lhs, const std:: tuple < UTypes... > & rhs ) ;	(2)	(начиная с C++11) (constexpr начиная с C++14) (до C++20)
template < class ... TTypes , class ... UTypes > bool operator < ( const std:: tuple < TTypes... > & lhs, const std:: tuple < UTypes... > & rhs ) ;	(3)	(начиная с C++11) (constexpr начиная с C++14) (до C++20)
template < class ... TTypes , class ... UTypes > bool operator <= ( const std:: tuple < TTypes... > & lhs, const std:: tuple < UTypes... > & rhs ) ;	(4)	(начиная с C++11) (constexpr начиная с C++14) (до C++20)
template < class ... TTypes , class ... UTypes > bool operator > ( const std:: tuple < TTypes... > & lhs, const std:: tuple < UTypes... > & rhs ) ;	(5)	(начиная с C++11) (constexpr начиная с C++14) (до C++20)
template < class ... TTypes , class ... UTypes > bool operator >= ( const std:: tuple < TTypes... > & lhs, const std:: tuple < UTypes... > & rhs ) ;	(6)	(начиная с C++11) (constexpr начиная с 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 ) не является корректным выражением для любого i в диапазоне

sizeof... ( Types )

, программа является некорректной.

Если тип и категория значения std :: get ( lhs ) == std :: get ( rhs ) не удовлетворяют требованиям BooleanTestable для любого i в диапазоне

sizeof... ( Types )

, поведение не определено.

(до C++26)

Эта перегрузка участвует в разрешении перегрузки только если sizeof... ( TTypes ) равно sizeof... ( UTypes ) , std :: get ( lhs ) == std :: get ( rhs ) является корректным выражением и decltype ( std :: get ( lhs ) == std :: get ( rhs ) ) моделирует


            
             boolean-testable

для каждого i в диапазоне

sizeof... ( Types )

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

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 ) , или любое из выражений сравнения, показанных в эквивалентных операторах, не является допустимым выражением, программа является некорректной.

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

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

**Примечание:** Весь код C++ внутри тегов ` ` сохранен без изменений, как и требовалось. HTML-теги, атрибуты и содержимое тегов `


        `, `
        `, ` $` также сохранены в оригинальном виде.$

8) То же, что и (1) , за исключением того, что rhs является


         
          tuple-like

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

9) То же, что и (7) , за исключением того, что rhs является


         
          tuple-like

объектом. /* Elems */ обозначает пакет типов std:: tuple_element_t < i, UTuple > для каждого i в

std:: tuple_size_v < UTuple >

в порядке возрастания. Данная перегрузка может быть найдена только через поиск, зависимый от аргументов .

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

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

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

Содержание

Параметры

lhs, rhs

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

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

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

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

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

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

Member functions
tuple::tuple
tuple::operator=
tuple::swap
Non-member functions
make_tuple
tie
forward_as_tuple
tuple_cat
operator== operator!= operator< operator<= operator> operator>= operator<=> (until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
swap (std::tuple)
get (std::tuple)
Helper concepts
`tuple-like` (C++23)
Helper classes
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
Deduction guides (C++17)

cppreference.net

Namespaces

Variants

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

Содержание

Параметры

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

Примечания

Пример

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

Смотрите также