¿Por qué esta afirmación if que combina la asignación y una verificación de igualdad devuelve verdadero?

He estado pensando en algunos errores de principiante y terminé con el de la ifdeclaración. Expandí un poco el código a esto:

int i = 0;
if (i = 1 && i == 0) {
    std::cout << i;
}

He visto que la ifdeclaración devuelve verdadero, y coutes icomo 1. Si ise asigna 1en la declaración if, ¿por qué i == 0regresó true?

Esto tiene que ver con la precedencia del operador .

if (i = 1 && i == 0)

no es

if ((i = 1) && (i == 0))

porque ambos &&y ==tienen una mayor precedencia que =. Lo que realmente funciona es

if (i = (1 && (i == 0)))

que asigna el resultado de 1 && (i == 0)a i. Entonces, si icomienza en, 0entonces i == 0es true, también lo 1 && truees true(o 1), y luego ise establece en 1. Entonces, dado que 1es verdadero, ingrese el bloque if e imprima el valor que le asignó i.

Asumiendo que su código en realidad se ve así:

#include <iostream>
using namespace std;

int main()  {
    int i = 0;
    if (i = 1 && i == 0) {
        cout << i;
    }
}

Luego esto:

if (i = 1 && i == 0) {

evalúa como

 if (i = (1 && i == 0)) {

y así ise establece en 1.

Tiene que ver con analizar y las reglas de derecha a izquierda. Por ejemplo, y = x + 5.
Todas las sub-expresiones son ponderadas en importancia. Dos expresiones de igual importancia se evalúan de derecha a izquierda,. El lado de expresión && se realiza primero, seguido del LHS.

Tiene sentido para mi.

La respuesta real es:

1. El compilador da prioridad a "i == 0", que se evalúa como verdadero.
2. Luego evaluará i = 1 como VERDADERO o FALSO, y dado que los operadores de asignación compilados nunca fallan (de lo contrario no compilarían), también se evalúa como verdadero.
3. Dado que ambas declaraciones se evalúan como verdaderas, y VERDADERO && VERDADERO se evalúa como VERDADERO, la declaración if se evaluará como VERDADERO.

Como prueba, solo mira la salida asm de tu compilador para el código que ingresaste (todos los comentarios son míos):

mov     dword ptr [rbp - 8], 0    ; i = 0;
cmp     dword ptr [rbp - 8], 0    ; i == 0?
sete    al                        ; TRUE (=1)
mov     cl, al
and     cl, 1                     ; = operator always TRUE
movzx   edx, cl
mov     dword ptr [rbp - 8], edx  ; set i=TRUE;
test    al, 1                     ; al never changed,
                                  ; so final ans is TRUE

La salida asm anterior era de CLANG, pero todos los otros compiladores que miré dieron una salida similar. Esto es cierto para todos los compiladores en ese sitio, ya sean compiladores C o C ++ puros, todo sin ningún pragma para cambiar el modo del compilador (que por defecto es C ++ para los compiladores C ++)

Tenga en cuenta que su compilador en realidad no estableció i = 1, pero i = TRUE (lo que significa cualquier valor entero no cero de 32 bits). Esto se debe a que el operador && solo evalúa si una declaración es VERDADERA o FALSA, y luego establece los resultados de acuerdo con ese resultado. Como prueba, intente cambiar i = 1 a i = 2 y podrá observar por sí mismo que nada cambiará. Compruébelo usted mismo utilizando cualquier compilador en línea en Compiler Explorer