Comparison operators

Les opérateurs de comparaison sont des opérateurs binaires qui testent une condition et retournent 1 si cette condition est logiquement vraie et 0 si cette condition est fausse .

Opérateurs relationnels

Les expressions d'opérateur relationnel ont la forme

Le type de toute expression d'opérateur relationnel est int , et sa valeur (qui n'est pas une lvalue) est 1 lorsque la relation spécifiée est vraie et ​ 0 ​ lorsque la relation spécifiée est fausse.

Si lhs et rhs sont des expressions de tout type réel , alors

• usual arithmetic conversions sont effectuées
• les valeurs des opérandes après conversion sont comparées selon le sens mathématique usuel (sauf que les zéros positifs et négatifs sont considérés comme égaux et toute comparaison impliquant une valeur NaN renvoie zéro)

Notez que les nombres complexes et imaginaires ne peuvent pas être comparés avec ces opérateurs.

Si lhs et rhs sont des expressions de type pointeur, elles doivent être toutes deux des pointeurs vers des objets de types compatibles , à l'exception des qualifications des objets pointés qui sont ignorées.

• un pointeur vers un objet qui n'est pas un élément d'un tableau est traité comme s'il pointait vers un élément d'un tableau avec un seul élément
• si deux pointeurs pointent vers le même objet, ou pointent tous deux juste après la fin du même tableau, ils sont considérés comme égaux
• si deux pointeurs pointent vers différents éléments du même tableau, celui pointant vers l'élément avec l'indice le plus grand est considéré comme supérieur
• si un pointeur pointe vers un élément d'un tableau et l'autre pointe juste après la fin du même tableau, le pointeur "juste après la fin" est considéré comme supérieur
• si les deux pointeurs pointent vers des membres d'une même struct , le pointeur vers le membre déclaré plus tard dans la définition de la structure est considéré comme supérieur au pointeur vers le membre déclaré plus tôt
• les pointeurs vers des membres d'une même union sont considérés comme égaux
• toutes les autres comparaisons de pointeurs invoquent un comportement indéfini

#include <assert.h>
int main(void)
{
    assert(1 < 2);
    assert(2+2 <= 4.0); // int converts to double, two 4.0's compare equal
    struct { int x,y; } s;
    assert(&s.x < &s.y); // struct members compare in order of declaration
    double d = 0.0/0.0; // NaN
    assert( !(d < d) );
    assert( !(d > d) );
    assert( !(d <= d) );
    assert( !(d >= d) );
    assert( !(d == d) );
    float f = 0.1; // f = 0.100000001490116119384765625
    double g = 0.1; // g = 0.1000000000000000055511151231257827021181583404541015625
    assert(f > g); // different values
}

Opérateurs d'égalité

Les expressions d'opérateur d'égalité ont la forme

Le type de toute expression d'opérateur d'égalité est int , et sa valeur (qui n'est pas une lvalue) est 1 lorsque la relation spécifiée est vraie et ​ 0 ​ lorsque la relation spécifiée n'est pas vraie.

• si les deux opérandes ont des types arithmétiques, les conversions arithmétiques usuelles sont effectuées et les valeurs résultantes sont comparées selon le sens mathématique usuel (sauf que les zéros positifs et négatifs sont considérés comme égaux et toute comparaison impliquant une valeur NaN, y compris l'égalité avec elle-même, retourne zéro). En particulier, les valeurs de type complexe sont égales si leurs parties réelles sont égales et leurs parties imaginaires sont égales.

• si un opérande est un pointeur et l'autre est une constante de pointeur nul, la constante de pointeur nul est d'abord convertie vers le type du pointeur (ce qui donne une valeur de pointeur nul), et les deux pointeurs sont comparés comme décrit ci-dessous
• si un opérande est un pointeur et l'autre est un pointeur vers void, le pointeur non-void est converti en pointeur vers void et les deux pointeurs sont comparés comme décrit ci-dessous
• deux pointeurs sont égaux si l'une des conditions suivantes est vraie :

• ils sont tous deux des valeurs de pointeur nul de leur type
• ils sont tous deux des pointeurs vers le même objet ou fonction
• un pointeur pointe vers un objet struct/union/tableau et l'autre vers son premier membre/n'importe quel membre/premier élément
• ils pointent tous deux juste après le dernier élément du même tableau
• l'un pointe juste après la fin d'un tableau, et l'autre au début d'un tableau différent (du même type) qui suit le premier dans un tableau plus grand ou dans une struct sans remplissage

(comme avec les opérateurs relationnels, les pointeurs vers des objets qui ne sont pas des éléments d'un tableau se comportent comme des pointeurs vers des éléments de tableaux de taille 1)

Notes

Les objets de type struct ne se comparent pas automatiquement comme égaux, et leur comparaison avec memcmp n'est pas fiable car les octets de remplissage peuvent avoir n'importe quelle valeur.

Parce que la comparaison de pointeurs fonctionne avec les pointeurs vers void, la macro NULL peut être définie comme ( void * ) 0 en C, bien que cela serait invalide en C++ où les pointeurs void ne se convertissent pas implicitement en pointeurs typés

Il faut prendre des précautions lors de la comparaison de valeurs à virgule flottante pour l'égalité, car les résultats de nombreuses opérations ne peuvent pas être représentés exactement et doivent être arrondis. En pratique, les nombres à virgule flottante sont généralement comparés en permettant une différence d'une ou plusieurs unités de la dernière place.

#include <assert.h>
int main(void)
{
    assert(2+2 == 4.0); // int converts to double, two 4.0's compare equal
    int n[2][3] = {1,2,3,4,5,6};
    int* p1 = &n[0][2]; // last element in the first row
    int* p2 = &n[1][0]; // start of second row
    assert(p1+1 == p2); // compare equal
    double d = 0.0/0.0; // NaN
    assert( d != d ); // NaN does not equal itself
    float f = 0.1; // f = 0.100000001490116119384765625
    double g = 0.1; // g = 0.1000000000000000055511151231257827021181583404541015625
    assert(f != g); // different values
}

Références

Voir aussi

Priorité des opérateurs