Pourquoi cette instruction if combinant affectation et vérification d'égalité renvoie-t-elle true?

J'ai pensé à quelques erreurs de débutant et je me suis retrouvé avec celui sur la ifdéclaration. J'ai développé un peu le code à ceci:

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

Je l' ai vu que les ifdéclarations de déclaration vrai, et il coutest icomme 1. Si iest affecté 1dans l'instruction if, pourquoi est-il i == 0revenu true?

Cela a à voir avec la priorité des opérateurs .

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

n'est pas

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

parce que les deux &&et ==ont une priorité plus élevée que =. Ce que ça donne vraiment, c'est

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

qui affecte le résultat de 1 && (i == 0)à i. Donc, si icommence à 0alors i == 0est true, il en 1 && trueest de même true(ou 1), puis iest réglé sur 1. Puisqu'il 1est vrai, vous entrez le bloc if et imprimez la valeur que vous avez affectée i.

En supposant que votre code ressemble à ceci:

#include <iostream>
using namespace std;

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

Ensuite ceci:

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

évalue comme

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

et iest donc réglé sur 1.

Cela a à voir avec l'analyse des règles de droite à gauche. Par exemple, y = x + 5.
Toutes les sous-expressions sont pondérées en importance. Deux expressions d'égale importance sont évaluées de droite à gauche,. Le côté expression && est effectué en premier, suivi du LHS.

Ça a du sens pour moi.

La vraie réponse est:

1. Le compilateur donne la priorité à "i == 0", qui a la valeur true.
2. Ensuite, il évaluera i = 1 comme VRAI ou FAUX, et puisque les opérateurs d'affectation compilés n'échouent jamais (sinon ils ne compileraient pas), il est également évalué comme vrai.
3. Étant donné que les deux instructions sont évaluées comme vraies et que TRUE && TRUE est évalué à TRUE, l'instruction if est évaluée à TRUE.

Pour preuve, regardez simplement la sortie asm de votre compilateur pour le code que vous avez entré (tous les commentaires sont les miens):

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 sortie asm ci-dessus provenait de CLANG, mais tous les autres compilateurs que j'ai examinés ont donné une sortie similaire. Cela est vrai pour tous les compilateurs sur ce site, qu'ils soient de purs compilateurs C ou C ++, tous sans pragmas pour changer le mode du compilateur (qui par défaut est C ++ pour les compilateurs C ++)

Notez que votre compilateur n'a pas réellement défini i = 1, mais i = TRUE (ce qui signifie toute valeur entière 32 bits non nulle). En effet, l'opérateur && évalue uniquement si une instruction est VRAI ou FAUX, puis définit les résultats en fonction de ce résultat. Pour preuve, essayez de changer i = 1 en i = 2 et vous pouvez constater par vous-même que rien ne changera. Voyez par vous-même à l'aide de n'importe quel compilateur en ligne dans Compiler Explorer