Tengo dos expresiones:

int a=5; 
int c=++a;// c=6, a=6
int b=a++;// b=6, a=7

En la segunda instrucción, el incremento se evalúa primero y en la tercera instrucción, el incremento se evalúa después de la asignación.

Sé que el operador de incremento tiene una prioridad más alta. ¿Alguien puede explicarme por qué se evalúa después de la asignación en la tercera expresión?

0
Constellation 19 abr. 2020 a las 03:42

2 respuestas

La mejor respuesta

El resultado no está relacionado con el orden de las operaciones, sino con la definición del prefijo ++ y el postfix ++.

La expresión ++a se evalúa como el valor incrementado de a. En contraste, la expresión a++ se evalúa como el valor actual de a, y a se incrementa como un efecto secundario.

Sección 6.5.2.4p2 del estándar C dice lo siguiente sobre postfix ++:

El resultado del operador postfix ++ es el valor de operando Como efecto secundario, el valor del objeto operando es incrementado (es decir, el valor 1 del tipo apropiado se agrega a eso).

Y la sección 6.5.3.1p2 dice lo siguiente sobre el prefijo ++:

El valor del operando del operador de prefijo ++ se incrementa. los El resultado es el nuevo valor del operando después del incremento. los la expresión ++E es equivalente a (E+=1)

5
dbush 19 abr. 2020 a las 00:52

++a y a++ son simplemente operadores diferentes, a pesar del mismo símbolo ++. Uno es prefijo-incremento, uno es postfix-incremento. Esto no tiene nada que ver con la prioridad en comparación con la asignación. (al igual que a - b y -a son operadores diferentes a pesar del mismo símbolo -).

EDITAR: se señaló que se trata de C y no de C ++ ... ¡Vaya! Entonces, la siguiente explicación puede ser confusa si solo conoce C; todo lo que necesita saber es que int& es una referencia a un int, por lo que es como tener un puntero pero sin la necesidad de desreferenciarlo, por lo que modificar a dentro de estas funciones en realidad modifica la variable que pasaste a las funciones.

Podrías imaginarlas como funciones:

int prefixIncrement(int& a) {
  return ++a;
}

... Es la misma que:

int prefixIncrement(int& a) {
  a += 1;
  return a;
}

Y:

int postfixIncrement(int& a) {
  return a++;
}

... Es la misma que:

int postfixIncrement(int& a) {
  int old = a;
  a += 1;
  return old;
}

Para nitpickers: Sí, en realidad necesitaríamos mover la semántica en el valor de retorno para postfixIncrement.

0
CherryDT 19 abr. 2020 a las 10:43