Comparison operators

Los operadores de comparación son operadores binarios que prueban una condición y devuelven 1 si esa condición es lógicamente true y 0 si esa condición es false .

Operadores relacionales

Las expresiones de operador relacional tienen la forma

El tipo de cualquier expresión de operador relacional es int , y su valor (que no es un lvalue) es 1 cuando la relación especificada se cumple y ​ 0 ​ cuando la relación especificada no se cumple.

Si lhs y rhs son expresiones de cualquier tipo real , entonces

• usual arithmetic conversions son realizadas
• los valores de los operandos después de la conversión son comparados en el sentido matemático usual (excepto que los ceros positivos y negativos se comparan como iguales y cualquier comparación que involucre un valor NaN devuelve cero)

Tenga en cuenta que los números complejos e imaginarios no se pueden comparar con estos operadores.

Si lhs y rhs son expresiones de tipo puntero, ambos deben ser punteros a objetos de tipos compatibles , excepto que se ignoran las calificaciones de los objetos apuntados.

• un puntero a un objeto que no es un elemento de un array se trata como si apuntara a un elemento de un array con un elemento
• si dos punteros apuntan al mismo objeto, o ambos apuntan una posición después del final del mismo array, se comparan como iguales
• si dos punteros apuntan a diferentes elementos del mismo array, el que apunta al elemento con el índice mayor se compara como mayor
• si un puntero apunta a un elemento de un array y el otro puntero apunta una posición después del final del mismo array, el puntero que apunta una posición después del final se compara como mayor
• si los dos punteros apuntan a miembros del mismo struct , el puntero al miembro declarado más tarde en la definición del struct se compara como mayor que el puntero al miembro declarado anteriormente
• los punteros a miembros de la misma unión se comparan como iguales
• todas las demás comparaciones de punteros invocan comportamiento indefinido

#include <assert.h>
int main(void)
{
    assert(1 < 2);
    assert(2+2 <= 4.0); // int convierte a double, dos 4.0 se comparan iguales
    struct { int x,y; } s;
    assert(&s.x < &s.y); // los miembros de struct se comparan en orden de declaración
    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); // valores diferentes
}

Operadores de igualdad

Las expresiones del operador de igualdad tienen la forma

El tipo de cualquier expresión de operador de igualdad es int , y su valor (que no es un lvalue) es 1 cuando la relación especificada se cumple y ​ 0 ​ cuando la relación especificada no se cumple.

• si ambos operandos tienen tipos aritméticos, conversiones aritméticas usuales son realizadas y los valores resultantes son comparados en el sentido matemático usual (excepto que los ceros positivos y negativos se comparan iguales y cualquier comparación que involucre un valor NaN, incluyendo igualdad consigo mismo, retorna cero). En particular, los valores de tipo complejo son iguales si sus partes reales se comparan iguales y sus partes imaginarias se comparan iguales.

• si un operando es un puntero y el otro es una constante de puntero nulo, la constante de puntero nulo primero se convierte al tipo del puntero (lo que da un valor de puntero nulo), y los dos punteros se comparan como se describe a continuación
• si un operando es un puntero y el otro es un puntero a void, el puntero no-void se convierte al puntero a void y los dos punteros se comparan como se describe a continuación
• dos punteros comparan iguales si cualquiera de los siguientes es verdadero:

• ambos son valores de puntero nulo de su tipo
• ambos son punteros al mismo objeto o función
• un puntero es a un objeto struct/union/array y el otro es a su primer miembro/cualquier miembro/primer elemento
• ambos apuntan a una posición después del último elemento del mismo array
• uno está después del final de un array, y el otro está al inicio de un array diferente (del mismo tipo) que sigue al primero en un array más grande o en un struct sin padding

(como con los operadores relacionales, los punteros a objetos que no son elementos de ningún array se comportan como punteros a elementos de arrays de tamaño 1)

Notas

Los objetos de tipo struct no se comparan iguales automáticamente, y compararlos con memcmp no es confiable porque los bytes de relleno pueden tener cualquier valor.

Debido a que la comparación de punteros funciona con punteros a void, la macro NULL puede definirse como ( void * ) 0 en C, aunque eso sería inválido en C++ donde los punteros void no se convierten implícitamente a punteros tipados

Se debe tener cuidado al comparar valores de punto flotante para igualdad, porque los resultados de muchas operaciones no pueden representarse exactamente y deben redondearse. En la práctica, los números de punto flotante usualmente se comparan permitiendo una diferencia de una o más unidades en el último lugar.

#include <assert.h>
int main(void)
{
    assert(2+2 == 4.0); // int se convierte a double, dos 4.0 se comparan iguales
    int n[2][3] = {1,2,3,4,5,6};
    int* p1 = &n[0][2]; // último elemento en la primera fila
    int* p2 = &n[1][0]; // inicio de la segunda fila
    assert(p1+1 == p2); // se comparan iguales
    double d = 0.0/0.0; // NaN
    assert( d != d ); // NaN no es igual a sí mismo
    float f = 0.1; // f = 0.100000001490116119384765625
    double g = 0.1; // g = 0.1000000000000000055511151231257827021181583404541015625
    assert(f != g); // valores diferentes
}

Referencias

Véase también

Precedencia de operadores