¿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?¿Es (4> y> 1) una declaración válida en C++? ¿Cómo lo evalúas si es así?
La declaración (4 > y > 1) se analiza como esto:
((4 > y) > 1)
Los operadores de comparación < y >evaluate left-to-right.
El 4 > y devuelve 0 o 1 dependiendo de si es verdadero o no.
A continuación, el resultado se compara con 1.
En este caso, puesto que 0 o 1 es nunca más de 1, la toda declaración falsa siempre devolverá.
Hay una excepción sin embargo:
Si y es una clase y el operador > se ha sobrecargado a hacer algo inusual. Entonces todo vale.
Por ejemplo, esto se producirá un error de compilar:
class mytype{
};
mytype operator>(int x,const mytype &y){
return mytype();
}
int main(){
mytype y;
cout << (4 > y > 1) << endl;
return 0;
}
Técnicamente, '4> y' devuelve' false' o 'true', que se convierten a' 0' o '1' para la próxima comparación. – fredoverflow
4> y se evaluará a un valor booleano de verdadero o falso. El resto de la expresión es esencialmente [verdadero | falso]> 1, lo cual no tiene sentido.
Tiene sentido cuando se da cuenta de que 'true' y' false' son valores enteros en C/C++. –
Ted: No, no lo son. Sin embargo, se pueden convertir ay desde. – GManNickG
@Gman: Un tecnicismo, pero relevante. La semántica puede ser cruel. –
Creo que es una expresión válida (no es una declaración), pero probablemente no hace lo que quiere. 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 entera siempre evaluará a 0 (falso).
Expresión Validez
Sí, es una expresión válida, asumiendo y es, o se puede convertir implícitamente en, un número entero. Si no es así y el operador > está sobrecargado, es una historia diferente fuera del alcance 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 se convierte efectivamente en true > 1 o false > 1.
Dada la implícita bool to int conversion, hay dos posibilidades: A) 4 > y devuelve true. true evalúa a 1. 1 > 1 se evalúa como falso. B) 4 > y devuelve false. false evalúa a 0. 0 > 1 se evalúa como falso.
No importa qué, la expresión se evaluará como falsa.
Refundido Interpretación
asumo lo que se propone es ((4 > y) && (y > 1)).
Ejemplo
(4 > y > 1) no es lo mismo que (4 > y && y > 1).
operadores lógicos
los operadores lógicos (!, &&, ||) usan la lógica de cortocircuito.
Dado a && b, a será evaluado. Si a se evalúa como verdadero, entonces se evaluará b. Else, b no se evaluará. En cuanto a 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 serán evaluados. Si a se evalúa como falso, entonces se evaluará b. Else, b no se evaluará. 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 operator precedence. Es mejor usar paréntesis y ser claro en lugar de arriesgar el comportamiento incorrecto.
4> y> 1 -> PUEDE SER DE TODOS MODOS si y - es clase !!.
#include <iostream>
#include <string>
struct num{ int n; };
struct op{ bool v; struct num n; };
struct op operator > (int x, num n){
struct op o = { x > n.n, n };
return o;
}
bool operator > (struct op o, int x)
{
return o.v && o.n.n > 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; }
}
duplicado Posible de [Soporte de idiomas para operadores de comparación encadenados (x