È (4> y> 1) un'istruzione valida in C++? Come valuti se così?

Question

È un'espressione valida? Se è così, puoi riscriverlo in modo che abbia più senso? Ad esempio, è lo stesso di (4 > y && y > 1)? Come valuti gli operatori logici concatenati?

Answer 1

La dichiarazione (4 > y > 1) viene analizzato come questo:

((4 > y) > 1) 

Gli operatori di confronto < e >evaluate left-to-right.

I 4 > y rendimenti sia 0 o 1 a seconda se è vero o no.

poi il risultato viene confrontato con 1.

In questo caso, dal momento che 0 o 1 è mai più di 1, l'intera dichiarazione restituisce sempre falso.

---

C'è un'eccezione però:

Se y è una classe e l'operatore > è stato sovraccaricato di 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; 
} 

Answer 2

4> y valuterà un valore booleano di vero o falso. Il resto dell'espressione è quindi essenzialmente [true | false]> 1, che non ha senso.

Answer 3

Penso che sia una valida espressione (non una dichiarazione), ma probabilmente non fa ciò che si vuole. Valuta da sinistra a destra, come (4 > y) > 1. Il test 4 > y verrà valutato su 0 (falso) o 1 (vero) e l'intera espressione verrà sempre valutata su 0 (falso).

Answer 4

Espressione validità

Sì, è un'espressione valida, assumendo y è, o può essere implicitamente convertito 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, prendiamo in considerazione le due possibilità. 4 > y può restituire true o false. La parte successiva diventa effettivamente true > 1 o false > 1.

Data l'implicita bool to int conversion, ci sono due possibilità: A) 4 > y restituisce true. true valuta a 1. 1 > 1 restituisce false. B) 4 > y restituisce false. false restituisce 0. 0 > 1 restituisce false.

Indipendentemente dall'espressione, l'espressione verrà valutata come falso.

Riscritto Interpretazione

presumo ciò che si intende è ((4 > y) && (y > 1)).

Esempio

(4 > y > 1) non è la stessa come (4 > y && y > 1).

operatori logici

gli operatori logici (!, &&, ||) utilizzano una logica corto circuito.

Dato a && b, a sarà valutato. Se a restituisce true, verrà valutato b. Altrimenti, b non verrà valutato. Per quanto riguarda a || b, la logica di cortocircuito funziona in senso inverso. a sarà valutato. Poiché l'espressione a viene valutata per prima, se è falsa, non vi è alcuna possibilità che l'intera espressione valuti true.

Dato a || b, a sarà valutato. Se a viene valutato come falso, verrà valutato b. Altrimenti, b non verrà valutato. Poiché l'espressione a viene valutata per prima, se è vera, non vi è alcuna possibilità che l'intera espressione valuti false.

Il concatenamento degli operatori è una questione di operator precedence. Meglio usare le parentesi e essere chiari piuttosto che rischiare il comportamento sbagliato.

Answer 5

4> y> 1 -> PUO ESSERE COMUNQUE se y - è di classe !!.

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