¿Qué es ++ p + ++ p si p es 20?

Answer 1

Hola,
Bueno, esta es una de las preguntas más interesantes.
Parece simple pero ¿verdad?

Bueno, por todas las conjeturas hechas … déjame decirte que la respuesta correcta es 44.

Ahora,
¿Por qué pasó esto?
Bueno, es algo que hace el compilador.
Nunca es seguro qué expresión se va a evaluar primero.

por tu ejemplo,
++ p + ++ p,
prefijo, usa el valor actual después de la actualización, es decir, usa el último valor. Cualquier operador, pre-arreglo o post-arreglo requeriría un punto de secuencia para reiniciar su valor para una evaluación adicional.

Por ejemplo, considere esto:

val1 = ++ p + p ++;

val2 = p ++ + ++ p;

para p = 10;

el valor de val1 = 23 y el de val2 = 22;

Vamos a resolverlo con la definición normal de operador pre y post-arreglo.
val1 = ++ p + p ++ => ++ p haría el valor de p = 11 (y usaría este valor), ahora p = 11, p ++ usaría el valor 11, luego lo actualizaría a 12. Pero el valor evaluado de val1 = 11 + 11 = 22;
Pero la respuesta real que da gcc es 23.

Entonces, ¿tenemos el conocimiento incorrecto sobre los operadores? ¿Fue todo un engaño que leímos en las escuelas / colegios?

Bueno, es algo llamado almacenamiento en búfer de expresiones.
Siempre que se evalúa una expresión con múltiples operadores (unarios), la corrección previa tiene una sobrecarga de usar el último valor que tiene la variable. es decir, después del final de la expresión, la variable ++ contendría el último o el valor más actualizado posible de esa variable.

por lo tanto con el ejemplo
Tuya –
++ p + ++ p,

Aquí, p = 10 … ahora, mientras que la evaluación primero ++ p haría que el valor de p = 11, luego ++ p haría que el valor sea p = 12;
Ahora, lo que sucede es que cuando el valor real se evalúa con el operador binario ‘+’, el valor que ++ p usa es el valor más actualizado … es decir, p = 12. Ambos operadores de pre-arreglo usarían este valor. De ahí la respuesta = 44.

Lo mismo sucede con mi ejemplo.

p = 10

val = ++ p + p ++;

++ p haría p = 11, luego p ++ usaría 11, pero luego cambiaría el valor a 12. ahora, al evaluar el operador binario ‘+’, ++ p (pre-arreglo) usa el valor más actualizado, es decir, 12,

por lo tanto…. val1 = 12 + 11 = 23;

Esto seguramente es una violación de lo que encontramos en las descripciones de estos operadores. Pero es básicamente la arquitectura y el compilador lo que daría como resultado diferentes salidas.
Lo que sucede en caso de CCG, bueno, eso acabo de explicar.

Espero que esto aclare.
Gracias

Answer 2

En lenguaje C, ” ++ p + ++ p” es una expresión que no tiene significado. Viola la regla de que la misma variable no se puede modificar más de una vez sin secuenciar: vea ¿Qué evalúa una expresión que involucra múltiples operadores de post / decremento / incremento en C y C ++? por los muchos clones de esta pregunta.

Tenga en cuenta que los compiladores generalmente producen algún código, pero sus resultados son basura. Los compiladores modernos también diagnostican esto con advertencias que siempre deben tratarse como errores:

Clang (opciones predeterminadas)

prog.c: 4: 5: advertencia: múltiples modificaciones no secuenciadas a ‘p’ [-Wunsequenced]
++ p + ++ p;
^ ~~

gcc (con -Wall)

prog.c: 4: 11: advertencia: la operación en ‘p’ puede estar indefinida [-Wsequence-point]
++ p + ++ p;
^ ~~

Answer 3

Gracias por A2A.

p es variable. ++ p es un incremento previo, por ejemplo:

Int a = 5;

++ a;

Salida: 6.

Entonces ++ p + ++ p = 21 + 22 = 43.

El incremento previo incrementa el valor en la misma línea. Entonces, por primera vez p = 21, después de otro pre-incremento p = 22.

Entonces 21 + 22 = 43.

Answer 4

Antes de responder esto, debe saber la diferencia entre el operador de prefijo y el de arreglo posterior.

++ p define una operación de prefijo en p. Esto significa que el valor de p se incrementará en 1 antes de que se realice cualquier otra operación.

p ++ define una operación de reparación posterior en p. Esto significa que el valor de p se incrementará en 1 solo después de que se haya realizado una operación en particular. La operación en caso de operador post arreglo se realizará utilizando el valor original de p.

Ahora llegando a tu pregunta

++ p +++ p

Divídalo usando corchetes en una secuencia lógica

(++ p) + (++ p)

Tenga en cuenta que ambos son operadores de prefijo.

Inicialmente, el valor de p es 20. Entonces, cuando se trata del primer paréntesis, el valor de p ya está incrementado a 21. Entonces, la expresión se reduce a

21 + (++ p) donde p es ahora 21.

Ahora, cuando el flujo de control llega al segundo tramo p, ya habrá sido incrementado en 1 a su nuevo valor de 22.

Entonces, la expresión final es en realidad 21 + 22, que es igual a 43.

Espero que haya sido útil.

Answer 5

P = 20

Se debe resolver el primer operador de preincremento

++ p + ++ p

Y el cálculo debe hacerse de derecha a izquierda, así que

++ p = 20 + 1 = 21

Entonces. ++ p + 21

Poniendo el valor de p como 21 obtenemos

21 + 1 + 21

= 43

Entonces la respuesta es 43.

Answer 6

La respuesta es 43. El operador utilizado aquí es el operador de incremento previo (++ p), primero aumentará el valor en un factor de 1 y luego aplicará la operación aritmética.

Entonces, primero aumentará de 20 a 21 y ahora el nuevo valor de p es 21, lo que aumentará aún más en la segunda declaración, por lo que el valor neto de expresión después de la compilación sería 43.

AV

Answer 7

Me gustaría consultar estos tutoriales para obtener más aclaraciones.

Orden de evaluación

Operadores de incremento / decremento

Léelo detenidamente.

Espero que funcione.

Answer 8

(++ P + ++ P) = ((20 + 1 = P) + (P + 1 = P)) = ((21) + (21 + 1 = P)) = (21 + 22) = 43

Y P = 22