operator==,!=,<,<=,>,>=,<=>(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, /* Elems */>...> 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 par operator==.

1) Renvoie true si toutes les paires d'éléments correspondants sont égales.

2) Renvoie !(lhs == rhs).

Si sizeof...(TTypes) n'est pas égal à sizeof...(UTypes), ou si std::get(lhs) == std::get(rhs) n'est pas une expression valide pour un i dans [0, sizeof...(Types)), le programme est mal formé.

Si le type et la catégorie de valeur de std::get(lhs) == std::get(rhs) ne satisfont pas aux exigences de BooleanTestable pour un i dans [0, sizeof...(Types)), le comportement est indéfini.

(jusqu'à C++26)

Cette surcharge participe à la résolution de surcharge uniquement si sizeof...(TTypes) est égal à sizeof...(UTypes), std::get(lhs) == std::get(rhs) est une expression valide et decltype(std::get(lhs) == std::get(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 seconds éléments, si ceux-ci sont équivalents, compare les troisièmes éléments, et ainsi de suite.

3) Pour les tuples vides, renvoie 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) Renvoie !(rhs < lhs).

5) Renvoie rhs < lhs.

6) Renvoie !(lhs < rhs).

Si sizeof...(TTypes) n'est pas égal à sizeof...(UTypes), ou si l'une des expressions de comparaison indiquées dans les instructions é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 indiquées dans les instructions équivalentes ne satisfont pas aux exigences de BooleanTestable, 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 seconds éléments, si ceux-ci sont équivalents, compare les troisièmes éléments, et ainsi de suite.

Pour les tuples vides, renvoie std::strong_ordering::equal.
Pour les tuples non vides, l'effet est équivalent à

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

Paramètres

lhs, rhs

-

tuples à comparer

Valeur de retour

1,8) true si std :: get ( lhs ) == std :: get ( 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

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

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

Support du compilateur
Libre et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support linguistique
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque de système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

Fonctions membres
tuple::tuple
tuple::operator=
tuple::swap
Fonctions non membres
make_tuple
tie
forward_as_tuple
tuple_cat
operator==operator!=operator<operator<=operator>operator>=operator<=> (jusqu'à C++20)(jusqu'à C++20)(jusqu'à C++20)(jusqu'à C++20)(jusqu'à C++20)(C++20)
swap(std::tuple)
get(std::tuple)
Concepts d'aide
`tuple-like` (C++23)
Classes d'aide
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
Guides de déduction(C++17)

fr.cppreference.net

Namespaces

Variants