Réponse courte
Tous les opérateurs +=
, -=
, *=
, /=
, &=
, |=
... sont l' arithmétique et offrent même attente:
x &= foo() // We expect foo() be called whatever the value of x
Cependant, les opérateurs &&=
et ||=
seraient logiques, et ces opérateurs pourraient être sujets aux erreurs car de nombreux développeurs s'attendent à foo()
être toujours appelés x &&= foo()
.
bool x;
// ...
x &&= foo(); // Many developers might be confused
x = x && foo(); // Still confusing but correct
x = x ? foo() : x; // Understandable
x = x ? foo() : false; // Understandable
if (x) x = foo(); // Obvious
Avons-nous vraiment besoin de rendre C / C ++ encore plus complexe pour obtenir un raccourci x = x && foo()
?
Voulons-nous vraiment obscurcir davantage la déclaration cryptique x = x && foo()
?
Ou voulons-nous écrire du code significatif comme if (x) x = foo();
?
Longue réponse
Exemple pour &&=
Si l' &&=
opérateur était disponible, alors ce code:
bool ok = true; //becomes false when at least a function returns false
ok &&= f1();
ok &&= f2(); //we may expect f2() is called whatever the f1() returned value
est équivalent à:
bool ok = true;
if (ok) ok = f1();
if (ok) ok = f2(); //f2() is called only when f1() returns true
Ce premier code est sujet aux erreurs car de nombreux développeurs penseraient qu'il f2()
est toujours appelé quelle que soit la f1()
valeur renvoyée. C'est comme écrire bool ok = f1() && f2();
où f2()
n'est appelé que lors du f1()
retour true
.
- Si le développeur souhaite réellement
f2()
être appelé uniquement lors des f1()
retours true
, le deuxième code ci-dessus est donc moins sujet aux erreurs.
- Sinon (le développeur veut
f2()
toujours être appelé), &=
suffit:
Exemple pour &=
bool ok = true;
ok &= f1();
ok &= f2(); //f2() always called whatever the f1() returned value
De plus, il est plus facile pour le compilateur d'optimiser ce code ci-dessus que celui du dessous:
bool ok = true;
if (!f1()) ok = false;
if (!f2()) ok = false; //f2() always called
Comparez &&
et&
On peut se demander si les opérateurs &&
et &
donnent le même résultat lorsqu'ils sont appliqués sur des bool
valeurs?
Vérifions en utilisant le code C ++ suivant:
#include <iostream>
void test (int testnumber, bool a, bool b)
{
std::cout << testnumber <<") a="<< a <<" and b="<< b <<"\n"
"a && b = "<< (a && b) <<"\n"
"a & b = "<< (a & b) <<"\n"
"======================" "\n";
}
int main ()
{
test (1, true, true);
test (2, true, false);
test (3, false, false);
test (4, false, true);
}
Production:
1) a=1 and b=1
a && b = 1
a & b = 1
======================
2) a=1 and b=0
a && b = 0
a & b = 0
======================
3) a=0 and b=0
a && b = 0
a & b = 0
======================
4) a=0 and b=1
a && b = 0
a & b = 0
======================
Conclusion
Par conséquent OUI, nous pouvons remplacer &&
par &
des bool
valeurs ;-)
Donc, mieux vaut utiliser &=
au lieu de &&=
.
Nous pouvons considérer&&=
comme inutile pour les booléens.
Pareil pour ||=
l'opérateur |=
est également moins sujet aux erreurs que||=
Si un développeur souhaite f2()
être appelé uniquement lors du f1()
retour false
, au lieu de:
bool ok = false;
ok ||= f1();
ok ||= f2(); //f2() is called only when f1() returns false
ok ||= f3(); //f3() is called only when f1() or f2() return false
ok ||= f4(); //f4() is called only when ...
Je conseille l'alternative plus compréhensible suivante:
bool ok = false;
if (!ok) ok = f1();
if (!ok) ok = f2();
if (!ok) ok = f3();
if (!ok) ok = f4();
// no comment required here (code is enough understandable)
ou si vous préférez tout dans un style de ligne :
// this comment is required to explain to developers that
// f2() is called only when f1() returns false, and so on...
bool ok = f1() || f2() || f3() || f4();