(4> y> 1) una dichiarazione valida in C ++? Come valuti se così?

È 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; } }