( 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,
s2[i]
a s1[i]
s1[i]
con \0
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 “).
( 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]
.
s1[i]
. !=
. El otro operando es el carácter literal '\0'
.