Les opérateurs & = et | = pour le court-circuit booléen?
Lors de l'écriture de code comme celui-ci en C++:
bool allTrue = true;
allTrue = allTrue && check_foo();
allTrue = allTrue && check_bar();
check_bar() ne sera pas évalué si check_foo() a renvoyé false. Cela s'appelle évaluation de court-circuit ou de court-circuit et fait partie du principe d'évaluation paresseux.
Est-ce que cela fonctionne avec l'opérateur d'affectation composé &=?
bool allTrue = true;
allTrue &= check_foo();
allTrue &= check_bar(); //what now?
Pour la logique OR remplacez tous & Par | Et true par false.
Depuis C++ 11 5.17 Assignment and compound assignment operators:
Le comportement d'une expression de la forme E1 op = E2 est équivalent à E1 = E1 op E2 sauf que E1 n'est évalué qu'une seule fois.
Cependant, vous mélangez un ET logique qui fait court-circuit, et l'ET au niveau du bit qui ne le fait jamais.
L'extrait de texte &&=, qui serait la façon dont vous feriez ce que vous demandez, est nulle part à trouver dans la norme. La raison en est qu'il n'existe pas réellement: il n'y a pas d'opérateur de logique et d'affectation.
L'évaluation de court-circuit (c.-à-d. Paresseux) est uniquement pour _ && et ||. Au niveau du bit & et | évalue les deux arguments.
Non, ils ne raccourcissent pas.
Notez que le &= et |= les opérateurs sont formés comme & + = et | + =. opérateurs de bits& et | n'effectue pas d'évaluation de raccourci.
Seulement opérateurs booléens&& et || l'exécuter.
Cela signifie qu'un opérateur de raccourci devrait être traditionnellement nommé &&= et ||=. Certaines langues les fournissent. C/C++ ne fonctionne pas.
Le code allTrue &= check_foo(); est équivalent à allTrue = allTrue & check_foo() Dans lequel vous utilisez bitwise AND et aucune évaluation paresseuse n'est effectuée.
Le bitwise AND doit prendre deux arguments dont la représentation binaire a la même longueur et utiliselogical AND opération pour comparer chaque paire de bits correspondante.
Première: a &= b; n'est pas la même chose que a = a && b;. a &= b; veux dire a = a & b;. En C/C++, il n'y a pas de a &&= b;.
Logique ET a && b est un peu comme un test pour 1 bit. Si le premier "bit" est déjà 0, le résultat sera toujours 0, peu importe le second. Il n'est donc pas nécessaire d'évaluer b si le résultat est déjà clair de a. La norme C/C++ permet cette optimisation.
Au niveau du bit ET a & b effectue ce test pour tous les bits de a et b. Donc b doit être évalué si au moins un bit dans a serait différent de zéro. Vous pourriez peut-être souhaiter que si a==0, que b ne serait pas évalué, mais cette optimisation n'est pas autorisée en C/C++.
Puisque & est une opération sur bits, check_foo () sera évalué en premier, quelle que soit la valeur de allTrue dans
allTrue &= check_foo(); // also for allTrue = allTrue & check_foo();
et aussi
allTrue &= check_bar(); // also for allTrue = allTrue & check_bar();
Cependant, check_foo () ne sera pas appelé si vous utilisez && et alltrue est faux comme dans:
allTrue = allTrue && check_foo();