Namespaces
Variants

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

    De fr.cppreference.net
     
    C++
    Support du compilateur
    Autonome 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 langage
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostics
    Bibliothèque de gestion 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èmes de fichiers (C++17)
    Bibliothèque de support de concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque d'utilitaires
    Support langage
    Support de types (types de base, RTTI)
    Macros de test de fonctionnalités de bibliothèque (C++20)
    Utilitaires de programme
    Fonctions variadiques
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Support de coroutines (C++20)
    Support de contrats (C++26)
    Comparaison à trois voies
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilitaires généraux
    Opérateurs relationnels (obsolète en C++20)
    Fonctions de comparaison d'entiers
    (C++20)(C++20)(C++20)    
    (C++20)
    Opérations d'échange et de type
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Types de vocabulaire courants
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    std::pair
     
    Défini dans l'en-tête <utility> 
    template< class T1, class T2, class U1, class U2 >
bool operator==( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(1) (jusqu'à C++14) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator==( const std::pair<T1, T2>& lhs,
                           const std::pair<U1, U2>& rhs );
    		(depuis C++14) 
    template< class T1, class T2, class U1, class U2 >
bool operator!=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(2) (jusqu'à C++14) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator!=( const std::pair<T1, T2>& lhs,
                           const std::pair<U1, U2>& rhs );
    		(depuis C++14)
    (jusqu'à C++20)    		 
    template< class T1, class T2, class U1, class U2 >
bool operator<( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(3) (jusqu'à C++14) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator<( const std::pair<T1, T2>& lhs,
                          const std::pair<U1, U2>& rhs );
    		(depuis C++14)
    (jusqu'à C++20)    		 
    template< class T1, class T2, class U1, class U2 >
bool operator<=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(4) (jusqu'à C++14) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator<=( const std::pair<T1, T2>& lhs,
                           const std::pair<U1, U2>& rhs );
    		(depuis C++14)
    (jusqu'à C++20)    		 
    template< class T1, class T2, class U1, class U2 >
bool operator>( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(5) (jusqu'à C++14) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator>( const std::pair<T1, T2>& lhs,
                          const std::pair<U1, U2>& rhs );
    		(depuis C++14)
    (jusqu'à C++20)    		 
    template< class T1, class T2, class U1, class U2 >
bool operator>=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(6) (jusqu'à C++14) 
    template< class T1, class T2, class U1, class U2 >
constexpr bool operator>=( const std::pair<T1, T2>& lhs,
                           const std::pair<U1, U2>& rhs );
    		(depuis C++14)
    (jusqu'à C++20)    		 
    template< class T1, class T2, class U1, class U2 >
constexpr std::common_comparison_category_t<synth-three-way-result<T1, U1>,
                                            synth-three-way-result<T2, U2>>
    operator<=>( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(7) (depuis C++20)
    1,2) Teste si les deux éléments de lhs et rhs sont égaux, c'est-à-dire compare lhs.first avec rhs.first et lhs.second avec rhs.second.

    Le comportement est indéfini si le type et la catégorie de valeur de lhs.first == rhs.first ou lhs.second == rhs.second ne satisfont pas aux exigences de BooleanTestable.

    		(jusqu'à C++26)

    Cette surcharge participe à la résolution de surcharge uniquement si decltype(lhs.first == rhs.first) et decltype(lhs.second == rhs.second) modélisent tous deux boolean-testable.

    		(depuis C++26)
    3-6) Compare lhs et rhs lexicographiquement avec operator<, c'est-à-dire compare les premiers éléments et seulement s'ils sont équivalents, compare les seconds éléments. Le comportement est indéfini si le type et la catégorie de valeur de l'un des lhs.first < rhs.first, rhs.first < lhs.first, ou lhs.second < rhs.second ne satisfont pas aux exigences de BooleanTestable.
    7) Compare lhs et rhs lexicographiquement avec synth-three-way, c'est-à-dire compare les premiers éléments et seulement s'ils sont équivalents, compare les seconds éléments. synth-three-way-result est le type de retour de synth-three-way.

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

    		(depuis C++20)

    Paramètres

    lhs, rhs - paires à comparer

    Valeur de retour

    1) true si les deux conditions lhs. first == rhs. first et lhs. second == rhs. second sont vérifiées, sinon false .
    2) ! ( lhs == rhs )
    3) Si lhs. first < rhs. first , retourne true . Sinon, si rhs. first < lhs. first , retourne false . Sinon, si lhs. second < rhs. second , retourne true . Sinon, retourne false .
    4) ! ( rhs < lhs )
    5) rhs < lhs
    6) ! ( lhs < rhs )
    7) synth-three-way ( lhs. first , rhs. first ) s'il n'est pas égal à ​ 0 ​ , sinon synth-three-way ( lhs. second , rhs. second ) .

    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::pair

    Exemple

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

    Exécuter ce code 
    #include <algorithm>
#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
int main()
{
    std::vector<std::pair<int, std::string>> v = {{2, "baz"}, {2, "bar"}, {1, "foo"}};
    std::sort(v.begin(), v.end());
    for (auto p : v)
        std::cout << '{' << p.first << ", " << std::quoted(p.second) << "}\n";
}

    Sortie : 

    {1, "foo"}
{2, "bar"}
{2, "baz"}

    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 correct
    LWG 296 C++98 les descriptions des opérateurs autres que == et < manquaient ajoutées
    LWG 2114
    ( P2167R3 )     		C++98 les préconditions de type pour les opérations booléennes manquaient ajoutées
    LWG 3865 C++98 les opérateurs de comparaison n'acceptaient que les pair s du même type acceptent les pair s de types différents

    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 le tuple
    (modèle de fonction)