Operador “-” en while () loop

Estoy leyendo el libro de K&R, en la página 63 hay una línea

while (--lim > 0 && (c=getchar()) != EOF && c != '\n') 

donde lim es int igual a 1000

Mi pregunta, ¿por qué lim no está disminuyendo después de las ejecuciones consiguientes del ciclo while? Como lo veo, –lim es equivalente a “lim = lim – 1”

================================================== =================

Gracias por todas las respuestas !

--lim significa “toma uno del valor de lim y usa el resultado”.

La alternativa lim-- sería “usar el valor de lim y luego quitar uno”.

Por lo tanto, si lim comienza a 1000 la primera vez que se ejecuta el bucle, tendrá el valor 999 antes de que se verifique para ver si es mayor que 0. Si fuera lim-- entonces el valor que se verificaría sería 1000 , pero Todavía tiene el valor de 999 al final de la iteración a través del bucle. Esto es importante al principio y al final del bucle.

El MSDN como una página en este Operador de Incremento y Decremento de Prefijo

Cuando el operador aparece antes de su operando, el operando se incrementa o disminuye y su nuevo valor es el resultado de la expresión.

¿Estás seguro?

 #include  int main() { int lim = 10; while (--lim > 0 && printf("%d\n",lim)); } 

salida

 9 8 7 6 5 4 3 2 1 

Lim está disminuyendo, probablemente cometió un error en otro lugar. Sin embargo, --lim no es exactamente igual a lim = lim - 1 .

Hay dos operadores para realizar el incremento / decremento de una variable: pre-incremento (o decremento) y post-incremento (o decremento).

++x (pre-inc) y x++ (post-inc) modifican el valor de x por +1. Entonces, ¿cuál es la diferencia?

Cuando use x++ en una expresión, la expresión considerará que x tiene su valor actual y, después de evaluar todo en consecuencia, incremente ese valor en uno. Asi que…

 int x = 5; printf("%d", x++); 

… imprimirá 5. SIN EMBARGO, después de la línea printf (), el valor de x será 6.

El pre-incremento funciona al revés: el valor de x se incrementa primero, y luego se considera evaluar la expresión que lo rodea. Asi que…

 int x = 5; printf("%d", ++x); 

… imprimirá 6 y, por supuesto, el valor de x será 6 después de eso.

Por supuesto, lo mismo se aplica a los operadores decremento.

Ahora, la operación de asignación ( x = x + 1 ) se evalúa al valor asignado, después de que se realizó la asignación, por lo que su comportamiento es en realidad similar a ++x , no x++ .

Intenta comstackr y ejecutar este código. Debería ser algo esclarecedor.

 #include  int main() { int lim = 10; while (--lim > 0 && 1 > 32) printf("I should never get here\n"); printf("%d\n",lim); // lim is now 9 } 

Oh, mira, lim ahora tiene 9 , aunque en realidad nunca entré en el bucle porque 1 no es mayor que 32.

--lim o lim-- es una mano corta de lim = lim - 1 , así que tal vez el autor quiera usar esta syntax para aclarar mejor.

Excluyendo el ejemplo de David (donde la prueba inicial de ‘c’ hace que el cuerpo del bucle nunca se ejecute, y por lo tanto lim no disminuye), y la posibilidad de que lim sea inicialmente menor o igual a 1 (en cuyo caso el getchar () no se ejecutaría), el código es equivalente a lo siguiente:

 c=getchar(); while (lim > 1 && c != EOF && c != '\n') { lim = lim - 1; /* Original body of loop */ c=getchar(); } 

Ambas excepciones son bastante improbables y probablemente intrascendentes, por lo que podría usar el código anterior si es más fácil de entender.