¿Cuál es la secuencia de ejecución para el código de abajo?

( s1[i] = s2[i] ) != '\0' 

¿La desigualdad comprueba s2[i] con '\0' o s1[i] ?

s2[ i ] se asignará a s1[ i ] y luego el valor de s1[ i ] se comparará con CERO.

Por favor, consulte aquí para más información.

En su idioma, verifica la desigualdad con s1[ i ] , pero en la siguiente secuencia,

  1. Asignar valor de s2[i] a s1[i]
  2. Compruebe el valor de s1[i] con \0
  3. Devuelve 1 o 0 según el paso 2 .

La expresión de la asignación devuelve el valor asignado :

El valor de la expresión es el valor del operando de la izquierda después de que se haya completado la asignación.

Así que cuando tengas

( s1[ i ] = s2[ i ] ) != '\0'

Luego está comparando el valor asignado (que es s1[i] ) a '\0' .

La desigualdad primero hace la asignación ( s1[i] = s2[i] ), luego verifica que s1[i] no es '\0' .

Supongo que fue en un caso afirmativo:

 if ((s1[i] = s2[i]) != '\0') ;// Do things 

es equivalente a :

 s1[i] = s2[i]; if (s1[i] != '\0') ;// Do things 

La precedencia del operador y el orden de evaluación determinan la secuencia de evaluación de la expresión.

El estado de precedencia del operador indica en qué orden interpretar una expresión, es decir, qué operadores pertenecen a qué operando. Es similar a la precedencia matemática, por ejemplo, 1+1*2 es 3 no 4, porque * tiene precedencia más alta que + . Debido a esa regla de precedencia, la expresión se evalúa como 1+(1*2) .

El orden de evaluación es algo diferente de la precedencia. Indica el orden en que se evalúan las subexpresiones. Otro ejemplo matemático: sabemos que (1*1) + (1+1) siempre es 3. Pero cuando calculamos eso, podemos decidir comenzar con el paréntesis izquierdo primero, o comenzar con el derecho. La precedencia de los operadores no decide con cuál empezamos. Aunque * tenga mayor prioridad que + , podríamos comenzar a calcular la expresión del lado derecho primero, y no afectaría el resultado.

Pero a la hora de progtwigr, este orden de evaluación a menudo importa. El comstackdor es el que decide este orden. Y para complicar las cosas, se permite hacer lo que le plazca sobre una base de caso por caso, sin documentar cómo (” comportamiento no especificado “).


  • El operador () tiene la mayor prioridad, por lo que ( s1[i] = s2[i] ) se evaluará primero. Todo lo que hay dentro es una subexpresión.
  • Dentro de la sub-expresión (), el operador [] tiene la siguiente prioridad, por lo que las dos ” s[i] ” se evalúan a continuación. Tenga en cuenta que ” s[i] ” también son subexpresiones, y como no se especifica el orden de evaluación de las subexpresiones, el comstackdor puede evaluar s1[i] antes o después de s2[i] .

    En este caso específico, el que sea evaluado primero probablemente no importa.

  • Dentro de la sub-expresión (), el operador = viene a continuación. El contenido del operando s2[i] se copia en s1[i] .

  • Todas las expresiones dentro de () ahora se evalúan, tenemos un resultado, almacenado en s1[i] .
  • Y, finalmente, este resultado de la subexpresión es un operando del operador restante de la expresión != . El otro operando es el carácter literal '\0' .