Ejemplo de operadores de comparación

Los operadores de comparación son operadores binarios que prueban una condición y devuelven 1 si esa condicion es logicamente cierto y 0 si esa condición es falso.

Operadores relacionales

Las expresiones del operador relacional tienen la forma.

1) expresión menor que2) expresión mayor que3) menor o igual expresión4) expresión mayor o igual

dónde.

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 es verdadera y ​0​ cuando la relación especificada no se cumple.

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

• se realizan conversiones aritméticas habituales
• los valores de los operandos después de la conversión se comparan en el sentido matemático habitual (excepto que los ceros positivos y negativos se comparan igual y cualquier comparación que implique un valor de 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, deben ser ambos 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 una matriz se trata como si apuntara a un elemento de una matriz con un elemento
• si dos punteros apuntan al mismo objeto, o ambos apuntan a uno más allá del final de la misma matriz, se comparan igual
• si dos punteros apuntan a diferentes elementos de la misma matriz, el que apunta al elemento con el índice más grande se compara con mayor.
• Si un puntero apunta al elemento de una matriz y el otro puntero apunta uno más allá del final de la misma matriz, el puntero de uno más allá del final compara mayor
• si los dos punteros apuntan a miembros de la misma estructura, el puntero al miembro declarado más adelante en la definición de la estructura se compara mayor que el puntero con el miembro declarado anteriormente.
• punteros a miembros de la misma unión comparar iguales
• todas las demás comparaciones de punteros invocan un comportamiento indefinido

#includeintmain(void)assert(1<2);assert(2+2<=4.0);// int converts to double, two 4.0's compare equalstructint x,y; s;assert(&s.x <&s.y);// struct members compare in order of declarationdouble d =0.0/0.0;// NaNassert(!(d < d));assert(!(d > d));assert(!(d >= d));assert(!(d >= d));float f =0.1;// f = 0.100000001490116119384765625double g =0.1;// g = 0.1000000000000000055511151231257827021181583404541015625assert(f > g);// different values

Operadores de igualdad

Las expresiones del operador de igualdad tienen la forma.

1) expresión igual a2) no es igual a la expresión

dónde.

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 es verdadera y ​0​ cuando la relación especificada no se cumple.

• si ambos operandos tienen tipos aritméticos, se realizan conversiones aritméticas habituales y los valores resultantes se comparan en el sentido matemático habitual (excepto que los ceros positivos y negativos se comparan igual y cualquier comparación que implique un valor de NaN, incluida la igualdad consigo mismo, devuelve cero). En particular, los valores de tipo complejo son iguales si sus partes reales son iguales y sus partes imaginarias son iguales.
• si un operando es un puntero y el otro es una constante de puntero nulo, la constante de puntero nulo se convierte primero al tipo de puntero (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 vacío, el puntero no vacío se convierte en el puntero a vacío y los dos punteros se comparan como se describe a continuación.
• dos punteros se comparan igual si se cumple alguna de las siguientes condiciones:
• ambos son valores de puntero nulo de su tipo
• Ambos son indicadores del mismo objeto.
• un puntero es a un objeto de estructura / unión / matriz y el otro es a su primer miembro / cualquier miembro / primer elemento
• ambos apuntan uno más allá del último elemento de la misma matriz
• uno es uno más allá del final de una matriz, y el otro está al comienzo de una matriz diferente (del mismo tipo) que sigue al primero en una matriz más grande o en una estructura sin relleno

(al igual que con los operadores relacionales, los punteros a objetos que no son elementos de ninguna matriz se comportan como punteros a elementos de matrices de tamaño 1).

Notas

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

Dado que la comparación de punteros funciona con punteros para anular, la macro NULL puede definirse como (void*)0 en C, aunque eso no sería válido en C ++, donde los punteros vacíos no se convierten implícitamente en punteros con tipo.

Se debe tener cuidado al comparar valores de punto flotante para la igualdad, porque los resultados de muchas operaciones no se pueden representar con exactitud y deben redondearse. En la práctica, los números de coma flotante generalmente se comparan teniendo en cuenta la diferencia de una o más unidades del último lugar.

#includeintmain(void)assert(2+2==4.0);// int converts to double, two 4.0's compare equalint n[2][3]=1,2,3,4,5,6;int* p1 =&n[0][2];// last element in the first rowint* p2 =&n[1][0];// start of second rowassert(p1+1== p2);// compare equaldouble d =0.0/0.0;// NaNassert( d != d );// NaN does not equal itselffloat f =0.1;// f = 0.100000001490116119384765625double g =0.1;// g = 0.1000000000000000055511151231257827021181583404541015625assert(f != g);// different values

Referencias

• Estándar C11 (ISO / IEC 9899: 2011):
• 6.5.8 Operadores relacionales (p: 95-96)
• 6.5.9 Operadores de igualdad (p: 96-97)
• Estándar C99 (ISO / IEC 9899: 1999):
• 6.5.8 Operadores relacionales (p: 85-86)
• 6.5.9 Operadores de igualdad (p: 86-87)
• Estándar C89 / C90 (ISO / IEC 9899: 1990):
• 3.3.8 Operadores relacionales
• 3.3.9 Operadores de igualdad

Ver también

Precedencia del operador.