Quando é apropriado usar um operador bit a bit em uma expressão condicional?

Primeiro, alguns antecedentes: sou professor de treinamento em TI e estou tentando introduzir os operadores booleanos de java na minha turma da 10ª série. Meu professor-mentor examinou uma planilha que eu preparei e comentei que poderia deixá-los usar apenas uma única & ou | denotar os operadores, porque "fazem a mesma coisa".

Estou ciente da diferença entre & e &&.
& é um operador bit a bit destinado ao uso entre números inteiros, para executar "ajustes de bits".
&& é um operador condicional destinado ao uso entre valores booleanos.

Para provar que esses operadores nem sempre "fazem a mesma coisa", propus-me a encontrar um exemplo em que o uso do bit a bit entre valores booleanos levaria a um erro. Eu encontrei este exemplo

boolean bitwise;
boolean conditional;
int i=10, j=12;
bitwise = (i<j) | ((i=3) > 5); // value of i after oper: 3
System.out.println(bitwise+ " "+ i);
i=10; 
conditional = (i<j) || (i=3) > 5 ;  // value of i after oper: 10
System.out.println(conditional+ " "+ i);
i=10; 
bitwise = (i>j) & (i=3) > 5;   // value of i after oper: 3
System.out.println(bitwise+ " "+ i);
i=10; 
conditional = (i>j) && (i=3) > 5;  // value of i after oper: 10
System.out.println(conditional+ " "+ i);

Este exemplo mostra que, se um valor tiver que ser alterado na segunda metade da expressão, isso levaria a uma diferença entre os resultados, já que o bit a bit é um operador ansioso, enquanto o condicional se comporta como um curto-circuito (não avalia o segundo metade, se a primeira metade for falsa no caso de && e verdadeira no caso de ||).

Eu tenho um problema com este exemplo. Por que você deseja alterar um valor ao mesmo tempo em que faz uma comparação? Não parece uma maneira robusta de codificar. Eu sempre fui avesso a fazer várias operações em uma única linha no meu código de produção. Parece algo que um "cowboy de codificação" sem consciência quanto à manutenção de seu código faria. Eu sei que em alguns domínios o código precisa ser o mais compacto possível, mas certamente essa é uma prática ruim em geral?

Eu posso explicar minha escolha de incentivar o uso de && e || sobre & e | porque esta é uma convenção de codificação aceita em engenharia de software .

Mas alguém poderia me dar um exemplo melhor, até do mundo real, do uso de um operador bit a bit em uma expressão condicional?

é apropriado quando você está executando uma operação de mascaramento

if ((a & b)> 0) {...}

onde aeb são números inteiros

|| e | e && e & não são intercambiáveis

| e & quase nunca aparecerão em uma expressão condicional por si mesmos (o ponto do link que você incluiu é que essas coisas geralmente são erros)

EDIT: Não discuta com seu mentor; mesmo se você ganhar, você perde. Em vez disso, explique que você não deseja confundir os alunos misturando operadores lógicos e operadores bit a bit na mesma lição. Você poderia explicar que, se i = 3 ej = 2, então i & j = 2, enquanto i && j é um erro. No entanto, a explicação mais simples é que você está ensinando operadores booleanos (lógicos), portanto, jogar equivalentes bit a bit em casos especiais é uma distração do ponto principal da lição. Não há necessidade de tornar o mentor "errado", nem de produzir contra-exemplos. O foco da lição está nos operadores booleanos, não nos operadores bit a bit.

Como corolário, quando você começa a ensinar aos operadores bit a bit, não há necessidade de mostrar os casos especiais em que + e - produzem os mesmos resultados que & e |

Os operadores não bit a bit &&e ||são operadores de curto-circuito. Em outras palavras, com &&, se o LHS for falso, o RHS nunca será avaliado; com ||se o LHS for verdadeiro, o RHS nunca será avaliado. Por outro lado, os operadores bit a bit &e |são sem curto-circuito e sempre avaliarão o LHS e o RHS. Caso contrário, eles são equivalentes em umif declaração.

A única vez em que vejo valor ao usar operadores sem curto-circuito é se o RHS tiver algum tipo de efeito colateral desejável que você deseja que aconteça em todos os casos. Não consigo pensar em um exemplo específico em que você queira isso e não acredito que seja uma boa prática, mas essa é a diferença.

A resposta filosófica geral é que o uso de operadores bit a bit para operadores booleanos é atípico e dificulta a leitura do código. Na prática (para código em produção), um código mais legível é mais fácil de manter e, portanto, mais desejável.

Para uma utilização real da necessidade de operadores de curto-circuito, consulte casos como:

if (args.length > 0 && args[0] == 'test') ....

if (b != NULL && b.some_function()) ...

if (b == NULL || b.some_function()) ...

Esse tipo de operação aparece frequentemente no código do mundo real.

Você usará operadores bit a bit se comparar as enumerações de Bitmask. Por exemplo, você tem uma enumeração de estados e um objeto que pode estar em mais de um desses estados. Nesse caso, você fará um bit a bit ou para atribuir mais de um estado ao seu objeto.

por exemplo, state = CONNECTED | IN_PROGRESSonde CONNECTED could be 0x00000001eIN_PROGRESS 0x00000010

Para obter mais informações, consulte a documentação de enumerações de sinalizadores.

um exemplo mais simples de erro:

int condA=1, condB=2;

if (condA!=0 && condB!=0) {
    // correct!
}
if ((condA & condB)!=0) {
    // never executed
}

aqui você tem duas condições, ambas são diferentes de zero; mas o bit a bit &resulta em zero.