É (4> y> 1) uma declaração válida em C ++? Como você avalia isso?

Isso é uma expressão válida? Se sim, você pode reescrevê-lo para que faça mais sentido? Por exemplo, é o mesmo que (4 > y && y > 1) ? Como você avalia os operadores lógicos encadeados?

    A declaração (4 > y > 1) é analisada como esta:

     ((4 > y) > 1) 

    Os operadores de comparação < e > avaliaram da esquerda para a direita .

    O 4 > y retorna 0 ou 1 dependendo se é verdade ou não.

    Então o resultado é comparado a 1.

    Nesse caso, como 0 ou 1 nunca é mais que 1 , toda a instrução sempre retornará false .


    Existe uma exceção:

    Se y é uma class e o operador > foi sobrecarregado para fazer algo incomum. Então vale tudo.

    Por exemplo, isso não conseguirá compilar:

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

    Validade de Expressão

    Sim, é uma expressão válida, assumindo que y é ou pode ser implicitamente convertido em um inteiro. Se não for e o operador > estiver sobrecarregado, é uma história diferente fora do escopo desta questão.

    Será avaliado da esquerda para a direita como ((4 > y) > 1) .

    Assumindo que y é um inteiro, vamos considerar as duas possibilidades. 4 > y pode retornar true ou false . A próxima parte efetivamente se torna true > 1 ou false > 1 .

    Dado o bool implícito para conversão int , existem duas possibilidades: A) 4 > y retorna true . true avalia para 1 . 1 > 1 avaliado como falso. B) 4 > y retorna false . false avalia para 0 . 0 > 1 avaliado como falso.

    Não importa o que, a expressão será avaliada como falsa.

    Interpretação Reescrita

    Eu assumo o que você pretende é ((4 > y) && (y > 1)) .

    Exemplo

    (4 > y > 1) não é o mesmo que (4 > y && y > 1) .

    Operadores lógicos

    Os operadores lógicos ( ! , && , || ) usam lógica de curto-circuito.

    Dado a && b , a será avaliado. Se a avaliação for verdadeira, então b será avaliado. Caso contrário, b não será avaliado . Quanto a a || b a || b , a lógica de curto-circuito funciona em sentido inverso. a será avaliado. Como a expressão a é avaliada primeiro, se for falsa, não há possibilidade de que toda a expressão seja avaliada como verdadeira.

    Dado a || b a || b , a será avaliado. Se a avaliação for falsa, então b será avaliado. Caso contrário, b não será avaliado . Como a expressão a é avaliada primeiro, se for verdadeira, não há possibilidade de que a expressão inteira seja avaliada como falsa.

    Encadear os operadores é uma questão de precedência do operador . É melhor usar parênteses e ser claro em vez de arriscar o comportamento errado.

    Eu acho que é uma expressão válida (não uma declaração), mas provavelmente não faz o que você quer. Ele avalia da esquerda para a direita como (4 > y) > 1 . O teste 4 > y será avaliado como 0 (falso) ou 1 (verdadeiro) e a expressão inteira será sempre avaliada como 0 (falso).

    4> y irá avaliar um valor booleano de verdadeiro ou falso. O restante da expressão é essencialmente [true | false]> 1, o que não faz sentido.

    4> y> 1 -> PODE SER DE QUALQUER MANEIRA se y – for 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; } }