Resposta curta
Todos os operadores +=
, -=
, *=
, /=
, &=
, |=
... são aritmética e fornecer mesma expectativa:
x &= foo() // We expect foo() be called whatever the value of x
No entanto, os operadores &&=
e ||=
seriam lógicos, e esses operadores podem estar sujeitos a erros, porque muitos desenvolvedores esperam que foo()
sejam sempre chamados 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
Nós realmente precisamos tornar o C / C ++ ainda mais complexo para obter um atalho x = x && foo()
?
Realmente queremos ofuscar mais a afirmação enigmática x = x && foo()
?
Ou queremos escrever um código significativo como if (x) x = foo();
?
Resposta longa
Exemplo para &&=
Se o &&=
operador estivesse disponível, este código:
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
é equivalente a:
bool ok = true;
if (ok) ok = f1();
if (ok) ok = f2(); //f2() is called only when f1() returns true
Esse primeiro código é suscetível a erros porque muitos desenvolvedores pensam que f2()
sempre é chamado de qualquer f1()
valor retornado. É como escrever bool ok = f1() && f2();
onde f2()
é chamado apenas quando f1()
retorna true
.
- Se o desenvolvedor realmente quiser
f2()
ser chamado apenas quando f1()
retornartrue
, o segundo código acima é menos suscetível a erros.
- Senão (o desenvolvedor quer
f2()
ser sempre chamado), &=
é suficiente:
Exemplo para &=
bool ok = true;
ok &= f1();
ok &= f2(); //f2() always called whatever the f1() returned value
Além disso, é mais fácil para o compilador otimizar esse código acima do que o código abaixo:
bool ok = true;
if (!f1()) ok = false;
if (!f2()) ok = false; //f2() always called
Compare &&
e&
Podemos nos perguntar se os operadores &&
e &
obter o mesmo resultado quando aplicados embool
valores?
Vamos verificar usando o seguinte código C ++:
#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);
}
Resultado:
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
======================
Conclusão
Portanto SIM podemos substituir &&
por &
em bool
valores ;-)
Então é melhor usar &=
em vez de &&=
.
Podemos considerar&&=
inútil para os booleanos.
O mesmo para ||=
operador |=
também é menos propenso a erros do que||=
Se um desenvolvedor quiser f2()
ser chamado apenas quando f1()
retornar false
, em vez 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 ...
Aconselho a seguinte alternativa mais compreensível:
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 se você preferir tudo em um estilo de linha :
// 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();