¿Por qué no se incrementa “k” en la statement “m = ++ i && ++ j || ++ k “cuando” ++ i && ++ j “se evalúa como verdadero?

¿No se supone que las expresiones individuales en una expresión lógica Y / O compuesta deben evaluarse primero antes de que los operadores lógicos se apliquen a su resultado? ¿Por qué no se ++k en la condición m = ++i && ++j || ++k m = ++i && ++j || ++k para el siguiente progtwig:

  #include int main() { int i=-3, j=2, k=0, m; m = ++i && ++j || ++k; printf("%d, %d, %d, %d\n", i, j, k, m); return 0; } 

Salida: -2,3,0,1

Pero espero que la salida -2,3,1,1

Debería evitar codificar un código ilegible. En realidad se analiza como

 m = (++i && ++j) || ++k; 

Así que una vez que j >= 0 la condición ++j siempre es verdadera, entonces ++k no se evalúa porque && es un atajo y luego pero || es un atajo corto o de lo contrario (por lo tanto, es posible que no evalúen su operando correcto).

Entonces && se evalúa de la siguiente manera: se evalúa el operando izquierdo, si es falso se devuelve, y solo cuando es verdadero (es decir, no igual a 0 ) el operando derecho se evalúa y se devuelve como el resultado evaluado de && . Del mismo modo || se evalúa de la siguiente manera: se evalúa el operando izquierdo. Si es verdadero (distinto de cero) se convierte en el resultado de || ; o bien el operando correcto es evaluado y es el resultado de || expresión.

En particular, cuando se codifica if (x > 0 && 20/x < 5) la división nunca se intenta para x==0 .

Lea también los operadores de wikipedia en C & C ++ y evaluación de cortocircuitos y páginas de evaluación diferida ; y por favor tome varias horas para leer un buen libro de progtwigción en C.

Los operadores lógicos tienen una evaluación de cortocircuito, es decir, tan pronto como se determina un valor para la expresión, el rest de la expresión no se evalúa.

por ejemplo, m = ++i && ++j || ++k; m = ++i && ++j || ++k; en este ++ i -> verdadero, ++ j -> verdadero (valor distinto de cero) por lo tanto m = true && true || ++k; m = true && true || ++k;

ahora cierto && cierto es cierto para

 m = true || ++k 

Como en el operador OR si 1 lado es verdadero, el otro no se evalúa, por lo que el resultado es verdadero.

Por lo tanto, k no se incrementa.

Ese es un atajo para operadores lógicos, en su operador de caso || . Cuando el primer operando es true , es imposible que el segundo operando tenga impacto en el resultado. Siempre será cierto, no importa lo que pueda producir el segundo operando. Por lo tanto, el segundo operando no se evalúa.

Lo mismo aplica para el operador lógico && , si el primer operando es false . El segundo operando no tendrá importancia, el resultado siempre será false y, por lo tanto, el segundo operando no será evaluado.

&& y || son operadores lógicos, y los está usando fuera de contexto que es impar (vale para C / C ++ pero tendría errores de tipo en Java o C #).

Acaba de descubrir operadores en cortocircuito: no necesita evaluar toda la expresión si “sabe” que es verdad. es decir, i y j no son cero, por lo que no es necesario que hagas nada con k, ya que sabes que la expresión es verdadera.

m = ++ i && ++ j || ++ k;

La primera línea de código ejecuta ++ i y ++ j primero y no ejecuta ++ k ya que está escrito después || (O)

Los operadores de circuitos lógicos no se ejecutan cuando la statement anterior es verdadera ya en el caso de || y falso en caso de &&

Por lo tanto k está intacto