Atajo para recordar el Orden de Evaluación y Precedencia de los Operadores en C

¿Hay algún atajo o una mejor manera de recordar la prioridad y el orden de evaluación en C porque puede desempeñar el papel principal y yo o (la mayoría de nosotros) generalmente se olvida y termina con el desorden? Por favor, ayúdame….

Quiero dar un ejemplo para esto … decir …

void main() { int a=1; a = a++ + ++a; printf("%d",a); }//prints 5; void main() { int a=1; int x; x = a++ + ++a; printf("%d",x); }//prints 4; 

también la expresión
x = ++a + a++;
da un resultado diferente

Espero que si el incremento de la publicación tenga una prioridad alta, a++ se evalúe primero. Por favor, elimíneme si no estoy bien y explíqueme cómo funciona.

En primer lugar, las expresiones de la forma a++ + ++a , ++a + a++ , etc., dan como resultado un comportamiento indefinido ; Cualquier resultado es posible. Desde el estándar de idioma ( n1256 ):

6.5 Expresiones

2 Entre el punto de secuencia anterior y el siguiente, un objeto tendrá su valor almacenado modificado a lo sumo una vez por la evaluación de una expresión. 72) Además, el valor anterior se leerá solo para determinar el valor que se almacenará. 73)

72) Un indicador de estado de punto flotante no es un objeto y se puede establecer más de una vez dentro de una expresión.

73) Este párrafo representa expresiones de statement no definidas como

         i = ++ i + 1;
         a [i ++] = i;

mientras que permite

         i = i + 1;
         a [i] = i;

Entonces, no hagas eso.

Una expresión bien definida como x = a++ + ++b se analizará como x = ((a++) + (++b)) ; ambas formas del operador ++ tienen mayor prioridad que la adición, y la adición tiene mayor prioridad que la asignación. El resultado de la expresión será el mismo que x = a + (b + 1) .

En segundo lugar, recuerde que los operadores ++ y -- tienen un resultado y un efecto secundario , como se muestra a continuación:

 Expresión Resultado efecto secundario
 ---------- ------ -----------
        i ++ ii = i + 1
        ++ ii + 1 i = i + 1
        i-- ii = i - 1
        --ii - 1 i = i - 1

Nota importante para recordar: el efecto secundario no debe aplicarse inmediatamente después de evaluar la expresión; solo debe aplicarse antes del siguiente punto de secuencia. Es posible que x = a++ + ++b se evalúe de la siguiente manera:

 t1 = a; t2 = b + 1; x = t1 + t2; b = b + 1; a = a + 1; 

En este caso, las actualizaciones de a y b se aplazan hasta después de la adición y la asignación a x .

En lo que respecta a la precedencia, aquí está el orden general de alto a bajo:

  1. Operadores de Postfix (todos tienen la misma prioridad, por lo que las secuencias de operadores se evaluarán de izquierda a derecha)
    • operador de subíndice de matriz []
    • operador de llamada de función ()
    • operadores de selección de componentes . y ->
    • postfix ++ y --
  2. Operadores unarios (todos tienen la misma prioridad, por lo que las secuencias de operadores se evaluarán de izquierda a derecha)
    • prefijo ++ y --
    • sizeof
    • operador de negación a nivel de bit ~
    • Operador de negación lógica !
    • operadores de señales unarias - y +
    • dirección del operador &
    • operador de desreferencia *
  3. Expresiones de lanzamiento ( nombre del tipo )
  4. Operadores multiplicativos * , / , %
  5. Operadores aditivos + y -
  6. Operadores de turnos << y >>
  7. Operadores relacionales < , > , <= , >=
  8. Operadores de igualdad == y !=
  9. Bitwise Y &
  10. Bitwise XOR ^
  11. Bitwise o |
  12. Lógica Y &&
  13. OR lógico ||
  14. Operador condicional ?:
  15. Operadores de asignación = , += . -= , *= , /= , %= , <<= , >>= , &= , ^= , |=
  16. Operador secuencial (coma) ,

Por lo tanto, las expresiones como *x++ se analizan como *(x++) , ya que postfix ++ tiene mayor prioridad que la unaria * . Del mismo modo, sizeof x + 1 se analiza como (sizeof x) + 1 , ya que sizeof tiene mayor prioridad que la adición. Una expresión como p++->x se analiza como (p++)->x ; los operadores postfix ++ y -> tienen la misma prioridad, por lo que se analizan de izquierda a derecha.

Esto es tan corto como los atajos de teclado; En caso de duda, utilizar paréntesis.

Haga como los pros: agregue paréntesis cuando no esté seguro. Entonces no tienes que recordar, además el código será más fácil de leer.

Hay un atajo para recordar la precedencia del operador C.

PUMA ES REBL (deletrea “REBL” como si “REBELDE”).

“I” en IS no representa a ningún operador y se utiliza para completar la oración.

(Nota: todos los operadores con asociatividad no especificada están de izquierda a derecha).

P – Primaria

U – Unario

M – Multiplicativa

A – Aditivo

S- Shift

R- Relacional

E- igualdad

B- BitWise (&> ^> |)

L- Lógica (lógica &&> lógica ||)

y los últimos tres operadores son

T- Ternario

A- Asignación

C- Coma

para Asociatividad Todos excepto Unary, Asignación y Ternario son de izquierda a derecha (AUTO viaja en la derecha, es decir, Asignación, Unario y Ternario son de derecha a izquierda).

Se recomienda ver los comentarios para la historia completa de PUMA.

Si lo encuentra confuso, también lo hará cualquiera que lea su código. En caso de duda, utilice los paréntesis para enfatizar.

Estoy de acuerdo con la otra publicación, siempre trate de usar paréntesis. Pero, si no quieres, aquí tienes, imprime esto y pégalo junto a tu computadora o algo así.

  • Tabla de Precedencia del Operador C

No debe confiar en su memoria cuando se trata de la precedencia del operador. Sólo en casos obvios. Cuáles son – presencia de operadores aritméticos, + – * /%. También es sabiendo que ++ y – tienen mayor prioridad que * para poder leer correctamente expresiones como *p++ = *q++; Las operaciones bitwise tienen reglas de precedencia locas. SIEMPRE use paréntesis para esos.

Para conocer la precedencia del operador, intente esto: 1: ARLA significa: A-> Operador aritmético R-> Operador relacional L-> Operador lógico A-> Operador de asignación 2: BODMAS B = corchetes primero ((,)) O = órdenes (como potencia) y cuadrado, etc.,) D = división (/) M = multiplicación (*) A = sum (+) S = resta (-)

es un cálculo simple cuando escribes int a = 1; x = a ++ + ++ a; Debido al operador de incremento de prefijo (en ++ a) el valor de ‘a’ será igual a 2 Por lo tanto, la expresión actual es equivalente a x = 2 + 2; // x = 4 Tan pronto como el control pasa a la siguiente línea, el valor de a se incrementa en 1 debido al operador postfix, ahora a = 3

Ahora examina esta statement int a = 1; a = a ++ + ++ a; En esta statement, como se explicó anteriormente, el valor de ‘a’ será igual a la expresión a = 2 + 2 ;. // significa a = 4 Pero debido al operador de incremento postfix (a ++) el valor de a aumenta en 1 tan pronto como el control cambia a la siguiente línea en el progtwig. Por lo tanto, printf (% d, a); Imprime 5 Espero que esto aclare tu duda.

En C, la tabla de precedencia especifica el orden de evaluación de la expresión y también especifica las reglas de asociación. Usando esa regla podemos evaluar el operador de igual prioridad (R-> L OR L-> R) en una expresión.
Tu específicas,
a = 1;
x = a ++ + ++ a;
1: ++ a entonces exp: a (2) ++ + 2 = 4 asigna a x
2: y luego incrementar a, se convierte en a = 3

supongamos que a = a ++ + ++ a; entonces
incrementar un
2 + 2 se asignan a un (4). incrementar a (5).

La respuesta promod o sus explicaciones no son correctas

El método correcto para recordar es

De todos los operadores previos, el incremento previo tiene la prioridad más alta.

Y de todas las operaciones de incremento posterior, el incremento de poste tiene la menor prioridad.

La adición tiene menor prioridad que los operadores pre y post incremento

Ahora considere el hecho de que Pre incremento cae en la categoría de derecha a izquierda

Y el incremento de Post cae en la clase de izquierda a derecha.

Teniendo en cuenta los dos casos, se puede elaborar el código.

 i = 1; i=i++ + ++i + ++i + i++; 

No ser 14 sino 12

Las dos expresiones del medio se evalúan a 4, luego 4 + 4 + 4

“El incremento / decremento de Postfix tiene una alta prioridad, pero el incremento o decremento real del operando se retrasa (se realizará en algún momento antes de que la instrucción complete la ejecución)”.

Esta es la prueba de enlace entrar enlace descripción aquí