Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::tuple
Défini dans l'en-tête <tuple>
template < class ... TTypes , class ... UTypes >

bool operator == ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(1) (depuis C++11)
(constexpr depuis C++14)
template < class ... TTypes , class ... UTypes >

bool operator ! = ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(2) (depuis C++11)
(constexpr depuis C++14)
(jusqu'à C++20)
template < class ... TTypes , class ... UTypes >

bool operator < ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(3) (depuis C++11)
(constexpr depuis C++14)
(jusqu'à C++20)
template < class ... TTypes , class ... UTypes >

bool operator <= ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(4) (depuis C++11)
(constexpr depuis C++14)
(jusqu'à C++20)
template < class ... TTypes , class ... UTypes >

bool operator > ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(5) (depuis C++11)
(constexpr depuis C++14)
(jusqu'à C++20)
template < class ... TTypes , class ... UTypes >

bool operator >= ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(6) (depuis C++11)
(constexpr depuis C++14)
(jusqu'à 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) (depuis C++20)
template < class ... TTypes , tuple - like UTuple >
constexpr bool operator == ( const tuple < TTypes... > & lhs, const UTuple & rhs ) ;
(8) (depuis C++23)
template < class ... TTypes , tuple - like UTuple >

constexpr std:: common_comparison_category_t <
synth - three - way - result < TTypes, /* Éléments */ > ... >

operator <=> ( const tuple < TTypes... > & lhs, const UTuple & rhs ) ;
(9) (depuis C++23)
1,2) Compare chaque élément du tuple lhs avec l'élément correspondant du tuple rhs via operator == .
1) Retourne true si toutes les paires d'éléments correspondants sont égales.
2) Retourne ! ( lhs == rhs ) .
Si sizeof... ( TTypes ) n'est pas égal à sizeof... ( UTypes ) , ou si std :: get < i > ( lhs ) == std :: get < i > ( rhs ) n'est pas une expression valide pour tout i dans [ ​ 0 ​ , sizeof... ( Types ) ) , le programme est mal formé.
Si le type et la catégorie de valeur de std :: get < i > ( lhs ) == std :: get < i > ( rhs ) ne satisfont pas aux exigences BooleanTestable pour tout i dans [ ​ 0 ​ , sizeof... ( Types ) ) , le comportement est indéfini.
(jusqu'à C++26)
Cette surcharge participe à la résolution de surcharge seulement si sizeof... ( TTypes ) est égal à sizeof... ( UTypes ) , std :: get < i > ( lhs ) == std :: get < i > ( rhs ) est une expression valide et decltype ( std :: get < i > ( lhs ) == std :: get < i > ( rhs ) ) modélise boolean-testable pour chaque i dans [ ​ 0 ​ , sizeof... ( Types ) ) .
(depuis C++26)
3-6) Compare lhs et rhs lexicographiquement par operator < , c'est-à-dire compare les premiers éléments, s'ils sont équivalents, compare les deuxièmes éléments, si ceux-ci sont équivalents, compare les troisièmes éléments, et ainsi de suite.
3) Pour les tuples vides, retourne false . Pour les tuples non vides, l'effet est équivalent à
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) Retourne ! ( rhs < lhs ) .
5) Retourne rhs < lhs .
6) Retourne ! ( lhs < rhs ) .
Si sizeof... ( TTypes ) n'est pas égal à sizeof... ( UTypes ) , ou si l'une des expressions de comparaison présentées dans les déclarations équivalentes n'est pas une expression valide, le programme est mal formé.
Si le type et la catégorie de valeur de l'une des expressions de comparaison présentées dans les déclarations équivalentes ne respectent pas les BooleanTestable exigences, le comportement est indéfini.
7) Compare lhs et rhs lexicographiquement par synth-three-way , c'est-à-dire compare les premiers éléments, s'ils sont équivalents, compare les deuxièmes éléments, si ceux-ci sont équivalents, compare les troisièmes éléments, et ainsi de suite.

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

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises ` ` qui contiennent du code source. Seul le texte en dehors de ces balises aurait été traduit, mais dans ce cas spécifique, il n'y a pas de texte libre à traduire en dehors du code C++.
8) Identique à (1) , sauf que rhs est un objet tuple-like , et le nombre d'éléments de rhs est déterminé par std:: tuple_size_v < UTuple > à la place. Cette surcharge ne peut être trouvée que via la recherche dépendante des arguments .
9) Identique à (7) , sauf que rhs est un objet de type tuple-like . /* Elems */ désigne le pack de types std:: tuple_element_t < i, UTuple > pour chaque i dans [ ​ 0 ​ , std:: tuple_size_v < UTuple > ) dans l'ordre croissant. Cette surcharge ne peut être trouvée que via la recherche dépendante des arguments .

Tous les opérateurs de comparaison sont court-circuités ; ils n'accèdent pas aux éléments du tuple au-delà de ce qui est nécessaire pour déterminer le résultat de la comparaison.

Les opérateurs < , <= , > , >= , et != sont synthétisés à partir de operator <=> et operator == respectivement.

(depuis C++20)

Table des matières

Paramètres

lhs, rhs - tuples à comparer

Valeur de retour

1,8) true si std :: get < i > ( lhs ) == std :: get < i > ( rhs ) pour tous les i dans [ ​ 0 ​ , sizeof... ( Types ) ) , sinon false . Pour deux tuples vides, retourne true .
2) ! ( lhs == rhs )
3) true si le premier élément non équivalent dans lhs est inférieur à celui dans rhs , false si le premier élément non équivalent dans rhs est inférieur à celui dans lhs ou s'il n'y a pas d'élément non équivalent. Pour deux tuples vides, retourne false .
4) ! ( rhs < lhs )
5) rhs < lhs
6) ! ( lhs < rhs )
7,9) La relation entre la première paire d'éléments non équivalents s'il y en a, std::strong_ordering::equal sinon. Pour deux tuples vides, retourne std::strong_ordering::equal .

Notes

Les opérateurs relationnels sont définis en termes de operator < de chaque élément.

(jusqu'à C++20)

Les opérateurs relationnels sont définis en termes de synth-three-way , qui utilise operator <=> si possible, ou operator < sinon.

Notamment, si un type d'élément ne fournit pas lui-même operator <=> , mais est implicitement convertible en un type comparable à trois voies, cette conversion sera utilisée à la place de operator < .

(depuis C++20)
Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_constrained_equality 202403L (C++26) Opérateur d'égalité contraint operator == pour std::tuple

Exemple

Parce que l'opérateur operator < est défini pour les tuples, les conteneurs de tuples peuvent être triés.

Exécuter ce code 
#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";
}

Sortie : 

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 2114
( P2167R3 ) 		C++11 les préconditions de type pour les opérations booléennes étaient manquantes ajoutées

Voir aussi

(supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (C++20)
compare lexicographiquement les valeurs dans la pair
(modèle de fonction)