È un’espressione valida? Se è così, puoi riscriverlo in modo che abbia più senso? Ad esempio, è uguale a (4 > y && y > 1) ? Come valuti gli operatori logici concatenati?
L’istruzione (4 > y > 1) viene analizzata come segue:
((4 > y) > 1)
Gli operatori di confronto < e > valutano da sinistra a destra .
Il 4 > y restituisce 0 o 1 seconda se è vero o no.
Quindi il risultato viene confrontato con 1.
In questo caso, poiché 0 o 1 non è mai più di 1 , l' intera istruzione restituirà sempre false .
C'è un'eccezione però:
Se y è una class e l'operatore > è stato sovraccaricato per fare qualcosa di insolito. Quindi tutto va bene.
Ad esempio, questo non riuscirà a compilare:
class mytype{ }; mytype operator>(int x,const mytype &y){ return mytype(); } int main(){ mytype y; cout << (4 > y > 1) << endl; return 0; }
Espressione Validità
Sì, è un’espressione valida, assumendo che y sia, o possa essere convertita implicitamente in, un numero intero. Se non lo è e l’operatore > è sovraccarico, è una storia diversa al di fuori dello scopo di questa domanda.
Sarà valutato da sinistra a destra come ((4 > y) > 1) .
Supponendo che y sia un numero intero, consideriamo le due possibilità. 4 > y può restituire true o false . La parte successiva diventa effettivamente true > 1 o false > 1 .
Data l’implicita conversione da bool a int , ci sono due possibilità: A) 4 > y restituisce true . true valuta a 1 . 1 > 1 restituisce false. B) 4 > y restituisce false . false valuta a 0 . 0 > 1 restituisce false.
Non importa cosa, l’espressione valuterà in falso.
Interpretazione riscritta
Presumo che cosa intendi sia ((4 > y) && (y > 1)) .
Esempio
(4 > y > 1) non è uguale a (4 > y && y > 1) .
Operatori logici
Gli operatori logici ( ! , && , || ) usano la logica di cortocircuito.
Dato a && b , verrà valutato a. Se a true, allora b sarà valutato. Altrimenti, b non sarà valutato . Per quanto riguarda a || b a || b , la logica di cortocircuito funziona al contrario. a sarà valutato. Poiché l’espressione a viene valutata per prima, se è falsa, non vi è alcuna possibilità che l’intera espressione valuti il vero.
Dato a || b a || b , sarà valutato. Se a valuta è falsa, allora b sarà valutato. Altrimenti, b non sarà valutato . Poiché l’espressione a viene valutata per prima, se è vera, non vi è alcuna possibilità che l’intera espressione valuti il falso.
Concatenare gli operatori è una questione di precedenza degli operatori . Meglio usare le parentesi e essere chiari piuttosto che rischiare il comportamento sbagliato.
Penso che sia un’espressione valida (non un’affermazione), ma probabilmente non fa quello che vuoi. Valuta da sinistra a destra, come (4 > y) > 1 . Il test 4 > y valuterà a 0 (falso) o a 1 (vero), e l’intera espressione valuterà sempre a 0 (falso).
4> y valuterà un valore booleano di vero o falso. Il resto dell’espressione è quindi essenzialmente [true | false]> 1, che non ha senso.
4> y> 1 -> PUO ESSERE COMUNQUE se y – è di class !!.
#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; } }