Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::pair
Member functions
(C++11)
Non-member functions
operator== operator!= operator< operator<= operator> operator>= operator<=>
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
(C++11)
(C++11)
Helper classes
(C++11)
(C++11)
(C++23)
(C++23)
(C++23)
(C++11)
Deduction guides (C++17)
Défini dans l'en-tête <utility>
(1)
template < class T1, class T2, class U1, class U2 >
bool operator == ( const std:: pair < T1, T2 > & lhs, const std:: pair < U1, U2 > & rhs ) ;
(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)
(2)
template < class T1, class T2, class U1, class U2 >
bool operator ! = ( const std:: pair < T1, T2 > & lhs, const std:: pair < U1, U2 > & rhs ) ;
(jusqu'en 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'en C++20)
(3)
template < class T1, class T2, class U1, class U2 >
bool operator < ( const std:: pair < T1, T2 > & lhs, const std:: pair < U1, U2 > & rhs ) ;
(jusqu'en 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'en C++20)
(4)
template < class T1, class T2, class U1, class U2 >
bool operator <= ( const std:: pair < T1, T2 > & lhs, const std:: pair < U1, U2 > & rhs ) ;
(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)
(5)
template < class T1, class T2, class U1, class U2 >
bool operator > ( const std:: pair < T1, T2 > & lhs, const std:: pair < U1, U2 > & rhs ) ;
(jusqu'au 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'au C++20)
(6)
template < class T1, class T2, class U1, class U2 >
bool operator >= ( const std:: pair < T1, T2 > & lhs, const std:: pair < U1, U2 > & rhs ) ;
(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 BooleanTestable .

(jusqu'à C++26)

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

(depuis C++26)
3-6) Compare lhs et rhs lexicographiquement par operator < , c'est-à-dire compare les premiers éléments et seulement s'ils sont équivalents, compare les deuxièmes éléments. Le comportement est indéfini si le type et la catégorie de valeur de l'une des expressions lhs. first < rhs. first , rhs. first < lhs. first , ou lhs. second < rhs. second ne satisfont pas aux exigences BooleanTestable .
7) Compare lhs et rhs lexicographiquement par synth-three-way , c'est-à-dire compare les premiers éléments et seulement s'ils sont équivalents, compare les deuxièmes é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)

Table des matières

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)