Comparison operators

Compare les arguments.

Comparaison bidirectionnelle

Les expressions d'opérateur de comparaison bidirectionnelle ont la forme

Opérateurs relationnels

Opérateurs d'égalité

Opérateurs de comparaison bidirectionnels intégrés

Pour les opérateurs de comparaison bidirectionnels intégrés, les conversions lvalue-vers-rvalue , les conversions tableau-vers-pointeur (jusqu'à C++26) et les conversions fonction-vers-pointeur sont appliquées à lhs et rhs .

Pour les opérateurs de comparaison bidirectionnels intégrés, le résultat est une bool prvalue.

Comparaison arithmétique intégrée

Si les opérandes converties ont toutes deux un type arithmétique ou énumération (scopé ou non scopé), les conversions arithmétiques usuelles sont effectuées sur les deux opérandes. Les valeurs sont comparées après les conversions :

#include <iostream>
int main()
{
    static_assert(sizeof(unsigned char) < sizeof(int),
                  "Cannot compare signed and smaller unsigned properly");
    int a = -1;
    int b = 1;
    unsigned int c = 1;
    unsigned char d = 1;
    std::cout << std::boolalpha
              << "Comparing two signed values:\n"
                 " -1 == 1 ? " << (a == b) << "\n"
                 " -1 <  1 ? " << (a <  b) << "\n"
                 " -1 >  1 ? " << (a >  b) << "\n"
                 "Comparing signed and unsigned:\n"
                 // may issue different-signedness warning:
                 " -1 == 1 ? " << (a == c) << "\n"
                 // may issue different-signedness warning:
                 " -1 <  1 ? " << (a <  c) << "\n"
                 // may issue different-signedness warning:
                 " -1 >  1 ? " << (a >  c) << "\n"
                 "Comparing signed and smaller unsigned:\n"
                 " -1 == 1 ? " << (a == d) << "\n"
                 " -1 <  1 ? " << (a <  d) << "\n"
                 " -1 >  1 ? " << (a >  d) << '\n';
}

Comparaison de deux valeurs signées :
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false
Comparaison entre signé et non signé :
 -1 == 1 ? false
 -1 <  1 ? false
 -1 >  1 ? true
Comparaison entre signé et non signé plus petit :
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false

Comparaison d'égalité des pointeurs intégrée

Les opérandes converties des opérateurs d'égalité == et != peuvent également avoir le type std::nullptr_t , (depuis C++11) un type pointeur ou un type pointeur-sur-membre.

La comparaison d'égalité des pointeurs natifs a trois résultats possibles : égal, inégal et non spécifié. Les valeurs produites par les opérateurs d'égalité pour la comparaison d'égalité des pointeurs natifs sont listées ci-dessous :

Si au moins l'un des lhs et rhs convertis est un pointeur, les conversions de pointeur , les conversions de pointeur de fonction (depuis C++17) et les conversions de qualification sont effectuées sur les deux opérandes convertis pour les amener à leur type de pointeur composite . Les deux pointeurs du type de pointeur composite sont comparés comme suit :

• Si un pointeur représente l'adresse d'un objet complet, et un autre pointeur

• représente l'adresse au-delà de la fin d'un autre objet complet non-tableau, ou
• représente l'adresse juste après le dernier élément d'un autre objet tableau complet,

le résultat de la comparaison n'est pas spécifié.

• Sinon, si les pointeurs sont tous deux nuls, pointent vers la même fonction, ou représentent la même adresse (c'est-à-dire qu'ils pointent ou sont au-delà de la fin du même objet), ils se comparent égaux.
• Sinon, les pointeurs se comparent inégaux.

Si au moins l'un des lhs et rhs convertis est un pointeur vers membre, les conversions pointeur-vers-membre , les conversions de pointeur de fonction (depuis C++17) et les conversions de qualification sont effectuées sur les deux opérandes convertis pour les amener à leur type de pointeur composite . Les deux pointeurs vers membres du type de pointeur composite sont comparés comme suit :

• Si deux pointeurs vers des membres sont tous deux la valeur de pointeur de membre nul, ils sont égaux.
• Si un seul des deux pointeurs vers des membres est la valeur de pointeur de membre nul, ils sont inégaux.
• Si l'un des deux est un pointeur vers une fonction membre virtuelle , le résultat est non spécifié.
• Si l'un se réfère à un membre de la classe C1 et l'autre à un membre d'une classe différente C2 , où aucune n'est une classe de base de l'autre, le résultat est non spécifié.
• Si les deux se réfèrent à des membres (éventuellement différents) de la même union , ils sont égaux.
• Sinon, deux pointeurs vers des membres sont égaux s'ils se réfèrent au même membre du même objet le plus dérivé ou du même sous-objet si une indirection avec un objet hypothétique du type de classe associé était effectuée, sinon ils sont inégaux.

struct P {};
struct Q : P { int x; };
struct R : P { int x; };
int P::*bx = (int(P::*)) &Q::x;
int P::*cx = (int(P::*)) &R::x;
bool b1 = (bx == cx); // non spécifié
struct B
{
    int f();
};
struct L : B {};
struct R : B {};
struct D : L, R {};
int (B::*pb)() = &B::f;
int (L::*pl)() = pb;
int (R::*pr)() = pb;
int (D::*pdl)() = pl;
int (D::*pdr)() = pr;
bool x = (pdl == pdr); // faux
bool y = (pb == pl);   // vrai

Comparaison relationnelle des pointeurs intégrés

Les opérandes converties des opérateurs relationnels > , < , >= et <= peuvent également avoir un type pointeur.

La comparaison relationnelle intégrée des pointeurs sur des pointeurs inégaux p et q a trois résultats possibles : p est supérieur, q est supérieur et non spécifié. Les valeurs produites par les opérateurs relationnels pour la comparaison relationnelle des pointeurs intégrés sont listées ci-dessous :

Si les lhs et rhs convertis sont tous deux des pointeurs, les conversions de pointeurs , les conversions de pointeurs de fonctions (depuis C++17) et les conversions de qualifications sont effectuées sur les deux opérandes convertis pour les amener à leur type de pointeur composite . Les deux pointeurs du type de pointeur composite sont comparés comme suit :

• Si les pointeurs sont égaux ou que le résultat de la comparaison d'égalité n'est pas spécifié, le résultat de la comparaison relationnelle tombe dans la même catégorie.
• Sinon (les pointeurs sont inégaux), si l'un des pointeurs n'est pas un pointeur vers un objet, le résultat n'est pas spécifié.
• Sinon (les deux pointeurs pointent vers des objets), le résultat est défini en termes d'un ordre partiel cohérent avec les règles suivantes :

• Étant donné deux éléments différents high et low d'un tableau tels que high a un indice supérieur à low , si un pointeur pointe vers high (ou un sous-objet de high ) et l'autre pointeur pointe vers low (ou un sous-objet de low ), le premier compare supérieur au second.
• Si un pointeur pointe vers un élément elem (ou vers un sous-objet de elem ) d'un tableau, et l'autre pointeur est au-delà de la fin du même tableau, le pointeur après-la-fin compare supérieur à l'autre pointeur.
• Si un pointeur pointe vers un objet complet, un sous-objet de classe de base ou un sous-objet membre obj (ou vers un sous-objet de obj ), et l'autre pointeur est au-delà de la fin de obj , le pointeur après-la-fin compare supérieur à l'autre pointeur.

• Si les pointeurs pointent vers différents non-zero-sized (since C++20) membres de données non statiques avec le même member access (until C++23) du même objet d'un type classe non-union, ou vers des sous-objets de tels membres, récursivement, le pointeur vers le membre déclaré plus tard compare supérieur à l'autre pointeur.
• Sinon, le résultat n'est pas spécifié.

Ordre total des pointeurs

Il existe un ordre total strict défini par l'implémentation sur les pointeurs dans chaque programme. L'ordre total strict est cohérent avec l'ordre partiel décrit ci-dessus : les résultats non spécifiés deviennent définis par l'implémentation, tandis que les autres résultats restent inchangés.

La comparaison de pointeurs avec l'ordre total strict est appliquée dans les cas suivants :

• Appeler l' operator ( ) des spécialisations de type pointeur de std::less , std::greater , std::less_equal , et std::greater_equal .

Surcharges

Dans la résolution de surcharge pour les opérateurs définis par l'utilisateur , pour chaque paire de types arithmétiques promus L et R , y compris les types énumération, les signatures de fonction suivantes participent à la résolution de surcharge :

Pour chaque type P qui est soit un pointeur vers un objet soit un pointeur vers une fonction, les signatures de fonction suivantes participent à la résolution de surcharge :

Pour chaque type MP qui est un pointeur vers un membre objet ou un pointeur vers une fonction membre ou std::nullptr_t (depuis C++11) , les signatures de fonction suivantes participent à la résolution de surcharge :

#include <iostream>
struct Foo
{
    int n1;
    int n2;
};
union Union
{
    int n;
    double d;
};
int main()
{
    std::cout << std::boolalpha;
    char a[4] = "abc";
    char* p1 = &a[1];
    char* p2 = &a[2];
    std::cout << "Pointers to array elements:\n"
              << "p1 == p2? " << (p1 == p2) << '\n'
              << "p1 <  p2? " << (p1 <  p2) << '\n';
    Foo f;
    int* p3 = &f.n1;
    int* p4 = &f.n2;
    std::cout << "Pointers to members of a class:\n"
              << "p3 == p4? " << (p3 == p4) << '\n'
              << "p3 <  p4? " << (p3 <  p4) << '\n';
    Union u;
    int* p5 = &u.n;
    double* p6 = &u.d;
    std::cout << "Pointers to members of a union:\n"
              << "p5 == (void*)p6? " << (p5 == (void*)p6) << '\n'
              << "p5 <  (void*)p6? " << (p5 <  (void*)p6) << '\n';
}

Pointers to array elements:
p1 == p2? false
p1 <  p2? true
Pointers to members of a class:
p3 == p4? false
p3 <  p4? true
Pointers to members of a union:
p5 == (void*)p6? true
p5 <  (void*)p6? false

#include <compare>
#include <iostream>
int main()
{
    double foo = -0.0;
    double bar = 0.0;
    auto res = foo <=> bar;
    if (res < 0)
        std::cout << "-0 is less than 0";
    else if (res > 0)
        std::cout << "-0 is greater than 0";
    else if (res == 0)
        std::cout << "-0 and 0 are equal";
    else
        std::cout << "-0 and 0 are unordered";
}

-0 and 0 are equal

Notes

Étant donné que les opérateurs de comparaison se regroupent de gauche à droite, l'expression a < b < c est analysée comme ( a < b ) < c , et non comme a < ( b < c ) ou ( a < b ) && ( b < c ) .

#include <iostream>
int main()
{
    int a = 3, b = 2, c = 1;
    std::cout << std::boolalpha
        << (a < b < c) << '\n' // true; peut-être un avertissement
        << ((a < b) < c) << '\n' // true
        << (a < (b < c)) << '\n' // false
        << ((a < b) && (b < c)) << '\n'; // false
}

Une exigence courante pour l'opérateur< défini par l'utilisateur est l'ordre faible strict . En particulier, cela est requis par les algorithmes standards et les conteneurs qui fonctionnent avec les types Compare : std::sort , std::max_element , std::map , etc.

Le résultat de comparaison des pointeurs vers différents membres de données non statiques de la même classe implique que les membres de données non statiques dans chacun des trois modes d'accès membre (jusqu'à C++23) sont positionnés en mémoire dans l'ordre de déclaration.

Bien que le résultat de la comparaison de pointeurs d'origine aléatoire (par exemple, ne pointant pas tous vers des membres du même tableau) soit non spécifié, de nombreuses implémentations fournissent un ordre total strict des pointeurs, par exemple s'ils sont implémentés comme des adresses dans un espace d'adressage virtuel continu. Les implémentations qui ne le font pas (par exemple, lorsque tous les bits du pointeur ne font pas partie d'une adresse mémoire et doivent être ignorés pour la comparaison, ou qu'un calcul supplémentaire est nécessaire, ou autrement lorsque la relation entre pointeur et entier n'est pas biunivoque), fournissent une spécialisation de std::less pour les pointeurs qui offre cette garantie. Cela permet d'utiliser tous les pointeurs d'origine aléatoire comme clés dans les conteneurs associatifs standards tels que std::set ou std::map .

Pour les types qui sont à la fois EqualityComparable et LessThanComparable , la bibliothèque standard C++ établit une distinction entre l'égalité , qui est la valeur de l'expression a == b et l'équivalence , qui est la valeur de l'expression ! ( a < b ) && ! ( b < a ) .

La comparaison entre les pointeurs et les constantes de pointeur nul a été supprimée par la résolution de CWG issue 583 incluse dans N3624 :

void f(char* p)
{
    if (p > 0) { /*...*/ } // Erreur avec N3624, compilait avant N3624
    if (p > nullptr) { /*...*/ } // Erreur avec N3624, compilait avant N3624
}
int main() {}

La comparaison à trois voies peut être générée automatiquement pour les types de classe, voir les comparaisons par défaut .

Si les deux opérandes sont des tableaux, la comparaison à trois voies est mal formée.

unsigned int i = 1;
auto r = -1 < i;    // piège existant : retourne 'false'
auto r2 = -1 <=> i; // Erreur : conversion restrictive requise

Bibliothèque standard

Les opérateurs de comparaison sont surchargés pour de nombreuses classes dans la bibliothèque standard.

L'espace de noms std::rel_ops fournit les opérateurs génériques ! = , > , <= , et >= :

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.

Voir aussi

• Priorité des opérateurs
• Surcharge des opérateurs
• Compare (exigences nommées)