¿Es (4> y> 1) una statement válida en C ++? ¿Cómo lo evalúas si es así?

¿Es esa una expresión válida? Si es así, ¿puedes reescribirlo para que tenga más sentido? Por ejemplo, ¿es lo mismo que (4 > y && y > 1) ? ¿Cómo evalúa operadores lógicos encadenados?

La instrucción (4 > y > 1) se analiza como esta:

 ((4 > y) > 1) 

Los operadores de comparación < y > evalúan de izquierda a derecha .

El 4 > y devuelve 0 o 1 dependiendo de si es verdadero o no.

Entonces el resultado se compara con 1.

En este caso, dado que 0 o 1 nunca es más de 1 , la instrucción completa siempre devolverá falsa .


Sin embargo, hay una excepción:

Si y es una clase y el operador > se ha sobrecargado para hacer algo inusual. Entonces todo vale.

Por ejemplo, esto no se comstackrá:

 class mytype{ }; mytype operator>(int x,const mytype &y){ return mytype(); } int main(){ mytype y; cout << (4 > y > 1) << endl; return 0; } 

Validez de expresión

Sí, es una expresión válida, suponiendo que y se puede convertir implícitamente en un entero. Si no es así y el operador > está sobrecargado, es una historia diferente fuera del scope de esta pregunta.

Se evaluará de izquierda a derecha como ((4 > y) > 1) .

Suponiendo que y es un número entero, consideremos las dos posibilidades. 4 > y puede devolver true o false . La siguiente parte pasa a ser true > 1 o false > 1 .

Dada la conversión implícita de bool a int , hay dos posibilidades: A) 4 > y devuelve true . true evalúa a 1 . 1 > 1 evalúa a falso. B) 4 > y devuelve false . false evalúa a 0 . 0 > 1 evalúa a falso.

No importa qué, la expresión evaluará a falso.

Interpretación reescrita

Supongo que lo que pretendes es ((4 > y) && (y > 1)) .

Ejemplo

(4 > y > 1) no es lo mismo que (4 > y && y > 1) .

Operadores logicos

Los operadores lógicos ( ! , && , || ) usan lógica de cortocircuito.

Dado a && b , a será evaluado. Si a evalúa como verdadero, entonces se evaluará b . De lo contrario, b no será evaluado . En cuanto a a || b a || b , la lógica de cortocircuito funciona a la inversa. a será evaluado. Como la expresión a se evalúa primero, si es falsa, no hay posibilidad de que toda la expresión evalúe verdadera.

Dado a || b a || b , a será evaluado. Si a evalúa como falso, entonces se evaluará b . De lo contrario, b no será evaluado . Como la expresión a se evalúa primero, si es verdadera, no hay posibilidad de que toda la expresión evalúe falsa.

Encadenar a los operadores es una cuestión de precedencia del operador . Es mejor usar paréntesis y ser claro en lugar de arriesgar el comportamiento incorrecto.

Creo que es una expresión válida (no una statement), pero probablemente no hace lo que quieres. Se evalúa de izquierda a derecha, como (4 > y) > 1 . La prueba 4 > y evaluará a 0 (falso) o 1 (verdadero), y la expresión completa siempre evaluará a 0 (falso).

4> y evaluará a un valor booleano de verdadero o falso. El rest de la expresión es esencialmente [verdadero | falso]> 1, lo cual no tiene sentido.

4> y> 1 -> PUEDE SER DE TODOS MODOS si y – es clase !!.

  #include  #include  struct num{ int n; }; struct op{ bool v; struct num n; }; struct op operator > (int x, num n){ struct op o = { x > nn, n }; return o; } bool operator > (struct op o, int x) { return ov && onn > x; } int main() { struct num y = { 2 } ; if ( 4 > y > 1 ) { std::cout << "4 > y > 1 TRUE" << std::endl; } else { std::cout << "4 > y > 1 ALWAYS FALSE" << std::endl; } } 
    Intereting Posts