Por que essa declaração if que combina atribuição e verificação de igualdade é verdadeira?

Eu estive pensando em alguns erros para iniciantes e acabei com o que estava na ifdeclaração. Expandi um pouco o código para isso:

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

Eu vi que a ifafirmação retorna verdadeira, e couté icomo 1. If ié atribuído 1na instrução if, por que i == 0retornou true?

Isso tem a ver com precedência do operador .

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

não é

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

porque ambos &&e ==têm uma precedência maior que =. O que realmente funciona é

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

que atribui o resultado de 1 && (i == 0)a i. Portanto, se icomeça em 0então , i == 0é true, também 1 && trueé true(ou 1) e ié definido como 1. Então, como 1é verdade, você insere o bloco if e imprime o valor atribuído i.

Assumindo que seu código realmente se parece com isso:

#include <iostream>
using namespace std;

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

Então isso:

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

avalia como

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

e assim iestá definido como 1.

Tem a ver com a análise de regras da direita para a esquerda. Por exemplo, y = x + 5.
Todas as subexpressões são ponderadas em importância. Duas expressões de igual importância são avaliadas da direita para a esquerda,. O lado da expressão && é feito primeiro, seguido pelo LHS.

Faz sentido para mim.

A resposta real é:

1. O compilador dá precedência para "i == 0", que é avaliado como verdadeiro.
2. Em seguida, ele avaliará i = 1 como VERDADEIRO ou FALSO, e como os operadores de atribuição compilados nunca falham (caso contrário, não compilariam), ele também avalia como verdadeiro.
3. Como as duas instruções são avaliadas como verdadeiras e TRUE && TRUE é avaliada como TRUE, a instrução if será avaliada como TRUE.

Como prova, basta olhar para a saída asm do seu compilador para o código digitado (todos os comentários são meus):

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

A saída asm acima era do CLANG, mas todos os outros compiladores que eu analisei deram saída semelhante. Isso é verdadeiro para todos os compiladores nesse site, sejam eles compiladores C ou C ++ puros, todos sem pragmas para alterar o modo do compilador (que por padrão é C ++ para os compiladores C ++)

Observe que seu compilador não definiu i = 1, mas i = TRUE (que significa qualquer valor inteiro de 32 bits e não zero). Isso ocorre porque o operador && avalia apenas se uma instrução é VERDADEIRA ou FALSA e, em seguida, define os resultados de acordo com esse resultado. Como prova, tente alterar i = 1 para i = 2 e observe por si mesmo que nada mudará. Veja você mesmo usando qualquer compilador online no Compiler Explorer