Quando è appropriato usare un operatore bit a bit in un'espressione condizionale?

In primo luogo, alcuni retroscena: sono un insegnante in formazione IT e sto cercando di introdurre gli operatori booleani di Java alla mia classe di 10 ° grado. Il mio insegnante-mentore ha esaminato un foglio di lavoro che ho preparato e ha commentato che potevo lasciarli usare solo un singolo & o | per indicare gli operatori, perché "fanno la stessa cosa".

Sono consapevole della differenza tra & e &&.
& è un operatore bit a bit destinato all'uso tra numeri interi, per eseguire "bit-twiddling".
&& è un operatore condizionale destinato all'uso tra valori booleani.

Per dimostrare che questi operatori non sempre "fanno la stessa cosa", ho deciso di trovare un esempio in cui l'uso del bitwise tra valori booleani comporterebbe un errore. Ho trovato questo esempio

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);

Questo esempio mostra che se un valore deve essere modificato dalla seconda metà dell'espressione, ciò porterebbe a una differenza tra i risultati, poiché bit a bit è un operatore desideroso, mentre il condizionale si comporta come un cortocircuito (non valuta la seconda metà, se la prima metà è falsa nel caso di && e vera nel caso di ||).

Ho un problema con questo esempio. Perché dovresti cambiare un valore contemporaneamente a un confronto su di esso? Non sembra un modo robusto per codificare. Sono sempre stato contrario a fare più operazioni in una sola riga nel mio codice di produzione. Sembra qualcosa che farebbe un "cowboy in codice" senza coscienza per quanto riguarda la manutenibilità del suo codice. So che in alcuni domini il codice deve essere il più compatto possibile, ma sicuramente questa è una cattiva pratica in generale?

Posso spiegare la mia scelta di incoraggiare l'uso di && e || oltre & e | perché questa è una convenzione di codifica accettata nell'ingegneria del software .

Ma qualcuno potrebbe darmi un esempio migliore, persino reale, dell'uso di un operatore bit per bit in un'espressione condizionale?

è appropriato quando si esegue un'operazione di mascheramento

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

dove aeb sono numeri interi

|| e | e && e & non sono intercambiabili

| e non compariranno mai in un'espressione condizionale da soli (il punto del collegamento che hai incluso è che spesso queste cose sono errori)

EDIT: non discutere con il tuo mentore; anche se vinci, perdi. Spiega invece che non vuoi confondere gli studenti mescolando operatori logici e operatori bit a bit nella stessa lezione. Potresti spiegare che se i = 3 e j = 2 allora i & j = 2, mentre i && j è un errore. Tuttavia, la spiegazione più semplice è che stai insegnando agli operatori booleani (logici), quindi inserire equivalenti bit per bit in casi speciali è una distrazione dal punto principale della lezione. Non è necessario rendere il mentore "sbagliato" e non è necessario produrre contro-esempi. Il focus della lezione è sugli operatori booleani, non sugli operatori bit a bit.

Come corollario, quando inizi a insegnare agli operatori bit a bit, non è necessario mostrare i casi speciali in cui + e - producono gli stessi risultati di & e |

Gli operatori non bit per bit &&e ||sono operatori di corto circuito. In altre parole, con &&, se l'LHS è falso, l'RHS non verrà mai valutato; con ||se il LHS è vero, allora il RHS sarà mai valutato. D'altra parte, gli operatori bit a bit &e |sono non in corto circuito, e valuteranno sempre sia l'LHS che l'RHS. Altrimenti, sono equivalenti in una ifdichiarazione.

L'unica volta in cui riesco a vedere un valore nell'uso degli operatori non in cortocircuito è se l'RHS ha qualche tipo di effetto collaterale desiderabile che si desidera che si verifichi in tutti i casi. Non riesco a pensare a un esempio specifico in cui lo vorresti, e non credo che sia una buona pratica, ma questa è la differenza.

La risposta filosofica generale è che l'uso di operatori bit per bit per operatori booleani è atipico e rende il codice più difficile da leggere. In pratica (per il codice in produzione), un codice più leggibile è più facile da mantenere e quindi più desiderabile.

Per un uso nel mondo reale della necessità di operatori di cortocircuito, vedere casi come:

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

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

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

Questo tipo di operazioni si presentano frequentemente nel codice del mondo reale.

Utilizzerai operatori bit per bit se confronti le enumerazioni della maschera di bit. Ad esempio, hai un elenco di stati e un oggetto che può trovarsi in più di uno di quegli stati. In questo caso, eseguirai un'operazione bit a bit o per assegnare più di uno stato al tuo oggetto.

per esempio state = CONNECTED | IN_PROGRESSdove CONNECTED could be 0x00000001eIN_PROGRESS 0x00000010

Per ulteriori informazioni, consultare la documentazione di enum flag.

un esempio più semplice di errore:

int condA=1, condB=2;

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

qui hai due condizioni, entrambe sono diverse da zero; ma bit &a bit si traduce in zero.