¿Qué hace que los desarrolladores de C tengan tanta curiosidad si "i ++ == ++ i"? [cerrado]

Sospecho que al menos una parte es un poco más simple: incluso ahora, vemos muchas preguntas como esta a partir del comienzo del año escolar, y gradualmente disminuyen a lo largo del año.

Como tal, creo que es justo suponer que algunos de ellos son simplemente el resultado de clases en las que el profesor habla al menos un poco al respecto, pero no explica su (s) punto (s) muy bien (ya que a menudo como no porque él mismo no los entiende realmente). Especialmente en función de las personas que parecen hacer estas preguntas, pocas se basan en la codificación real.

Porque los programadores C TIENEN que entender el orden de las operaciones. Los desarrolladores de C # no necesariamente utilizan los operadores bitwise (& amp ;, |, ~) o los operadores de prefijo, ya que normalmente estamos más preocupados por otras cosas. Sin embargo, los desarrolladores de C # no nos damos cuenta de que deberíamos saber qué hacen los operadores que utilizamos a diario y cómo usarlos correctamente. La mayoría de nosotros simplemente evitamos los lugares donde esto puede ser un problema.

Fuera de la parte superior de tu cabeza, ¿cuál es el resultado de este fragmento?

    double x = 5.5;
    Console.WriteLine(x++);
    x = 5.5;
    Console.WriteLine(++x);

Diría que un buen número de desarrolladores de C # experimentados no tienen idea de cuál es el resultado de la Consola.

Creo que esto es obvio. En C #, para un int i , i++ == ++i siempre es falso, mientras que ++i == i++ siempre es cierto, de manera confiable, y todos los que estén interesados pueden descubrirlo fácilmente simplemente aprendiendo las reglas de C # (o simplemente ejecutándolo).

Por otro lado, en C y C ++, está cerca de no definido porque depende del compilador, el entorno de ejecución, la plataforma, etc., por lo que es una pregunta mucho más difícil de responder, por lo que mucha gente la pregunta.

Muy probablemente porque en C, realmente importa si escribes i++ o ++i cuando estás haciendo aritmética de punteros. Allí, aumentar i antes o después de una operación podría ser crucial. Te daría un ejemplo, pero la última vez que escribí C fue hace 10 años ...

En C #, nunca he encontrado una situación que requiera que piense en i++ o ++i porque AFAIK, para los bucles for / while, realmente no importa.

Es una pregunta popular porque es una pregunta con trampa. No está definido .

El enlace de arriba va a una sección de preguntas frecuentes en la página de inicio de Bjarnes Stroustrup, que aborda esta pregunta específicamente, y explica por qué esta construcción no está definida. Lo que dice es:

  

Básicamente, en C y C ++, si lees una variable dos veces en una expresión donde también la escribes, el resultado no está definido.

     

Se dice que tener el orden de evaluación indefinido produce un código de mejor rendimiento.

Hace unos años leí que estos operadores eran considerados peligrosos, así que traté de buscar más información al respecto. Si Stackoverflow hubiera estado activo en ese momento, lo habría preguntado allí.

Ahora es porque algunas personas retorcidas escriben bucles como

while( [something] )
{
  a[++j] = ++j;
}

Incluso ahora, no estoy muy seguro de lo que ocurrirá / debería suceder, pero para mí es bastante claro que múltiples ++ [var] en la misma línea están pidiendo problemas.

Dos razones.

La implementación correcta de ++ i es incrementar i y luego devolverla. La implementación correcta de i ++ es guardar el valor actual, incrementar i y devolver el valor guardado. Saber que estos no están implementados como sinónimos es importante.

La pregunta se convierte en cuando el compilador las aplica al evaluar una expresión, como la igualdad.

Si primero se realiza la prueba de igualdad, luego los operadores pre y post-incremento, tendrá que escribir una lógica diferente que si se evalúan el lado izquierdo (lhs) y el lado derecho (rhs) Primero, luego la igualdad.

Todo se trata del orden de las operaciones, y eso a su vez afecta el código que se escribe. Y, como es lógico, no todos los idiomas están de acuerdo.

La lista de pruebas básicas permite a los desarrolladores probar si sus suposiciones son correctas, así como si la implementación real coincide con la especificación del idioma.

Esto puede tener todo tipo de impacto al trabajar con punteros, bucles o valores de retorno.

Creo que es un choque cultural.

Como ya se señaló, el comportamiento de una expresión en C o C ++ puede no estar definido porque el orden de ejecución de los post-incrementos, etc. no está estrictamente definido. El comportamiento indefinido es bastante común en C y, por supuesto, mucho de eso se importó a C ++.

Para alguien que ha programado en otro idioma, alguien que ha captado la idea de que se supone que los lenguajes de programación son precisos y que las computadoras deben hacer lo que se les dice que hagan ... bueno, es fue un shock descubrir que C es intencionalmente vago acerca de algunas cosas.

Quizás es solo que los desarrolladores de C usan ++ incrementación más a menudo en general, ya que C no tiene una instrucción "foreach" o similar para iterar a través de matrices. Ah, y por supuesto, la aritmética del puntero, como se mencionó anteriormente!

La diferencia entre ambas partes: el post y el preincremento están funcionando de la manera en que estas dos piezas de código deberían funcionar en todos los idiomas. ¡¡¡ESTO NO SERÁ DEPENDIENTE DEL IDIOMA !!!

++i

Esto es pre incremento. Este fragmento de código primero aumentará el valor de i antes de enviar el valor a la línea donde se usa.

i++

Este es el incremento de la publicación. Este fragmento de código devolverá el valor de i antes de que aumente el valor de i en la línea donde se usa.

En otro pequeño ejemplo:

int main(void)
{
  int i = 0; 
  int result; 
  result = 10 + ++i; 
  printf("%d \n", result); // = 11 

  int j = 0; 
  result = 10 + j++; 
  printf("%d \n", result);// = 10
  return 0;
}

Este código se compila con los resultados en el teclado.

Esto tiene que ver con la implementación interna de la sobrecarga del operador.

++i aumenta directamente el valor (y, por lo tanto, es un poco más rápido)

i++ primero crea una copia que se devuelve al lugar donde se necesita y luego el valor original de la variable i se incrementa en uno.

Espero que esto esté claro ahora.