Quand est-il approprié d'utiliser un opérateur au niveau du bit dans une expression conditionnelle?

Tout d'abord, quelques antécédents: je suis professeur d'informatique en formation et j'essaie de présenter les opérateurs booléens de java à ma classe de 10e année. Mon enseignant-mentor a examiné une feuille de travail que j'avais préparée et a fait remarquer que je pouvais les laisser utiliser un seul & ou | pour désigner les opérateurs, car ils "font la même chose".

Je suis conscient de la différence entre & et &&.
& est un opérateur au niveau du bit destiné à être utilisé entre des entiers, pour effectuer un "twiddling de bits".
&& est un opérateur conditionnel destiné à être utilisé entre des valeurs booléennes.

Pour prouver que ces opérateurs ne "font pas toujours la même chose", j'ai cherché un exemple où l'utilisation du bit entre les valeurs booléennes conduirait à une erreur. J'ai trouvé cet exemple

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

Cet exemple montre que si une valeur doit être modifiée par la seconde moitié de l'expression, cela entraînerait une différence entre les résultats, car bitwise est un opérateur impatient, tandis que le conditionnel se comporte comme un court-circuit (n'évalue pas la seconde moitié, si la première moitié est fausse dans le cas de && et vraie dans le cas de ||).

J'ai un problème avec cet exemple. Pourquoi voudriez-vous changer une valeur en même temps que vous faites une comparaison dessus? Cela ne semble pas être un moyen robuste de coder. J'ai toujours été opposé à faire plusieurs opérations sur une seule ligne dans mon code de production. Cela ressemble à quelque chose que ferait un "cowboy codeur" sans conscience quant à la maintenabilité de son code. Je sais que dans certains domaines, le code doit être aussi compact que possible, mais c'est certainement une mauvaise pratique en général?

Je peux expliquer mon choix d'encourager l'utilisation de && et || sur & et | car il s'agit d' une convention de codage acceptée en génie logiciel .

Mais quelqu'un pourrait-il me donner un meilleur exemple, même réel, d'utilisation d'un opérateur au niveau du bit dans une expression conditionnelle?

il est approprié lorsque vous effectuez une opération de masquage

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

où a et b sont des entiers

|| et | et && et & ne sont pas interchangeables

| et & n'apparaîtra presque jamais dans une expression conditionnelle par eux-mêmes (le point du lien que vous avez inclus est que de telles choses sont le plus souvent des erreurs)

EDIT: Ne discutez pas avec votre mentor; même si vous gagnez, vous perdez. Expliquez plutôt que vous ne voulez pas confondre les élèves en mélangeant des opérateurs logiques et des opérateurs au niveau du bit dans la même leçon. Vous pourriez expliquer que si i = 3 et j = 2 alors i & j = 2, alors que i && j est une erreur. Cependant, l'explication plus simple est que vous enseignez des opérateurs booléens (logiques), donc jeter des équivalents au niveau du cas spécial est une distraction par rapport au point principal de la leçon. Il n'est pas nécessaire de rendre le mentor «mauvais», ni de produire des contre-exemples. La leçon se concentre sur les opérateurs booléens, et non sur les opérateurs au niveau du bit.

En corollaire, lorsque vous commencez à enseigner des opérateurs au niveau du bit, il n'est pas nécessaire de montrer les cas particuliers où + et - produisent les mêmes résultats que & et |

Les opérateurs non binaires &&et ||sont des opérateurs de court-circuit. En d'autres termes, avec &&, si le LHS est faux, le RHS ne sera jamais évalué; avec ||si le LHS est vrai, l'ERS ne sera jamais évaluée. D'un autre côté, les opérateurs au niveau du bit &et ne |sont pas en court-circuit, et évalueront toujours à la fois le LHS et le RHS. Sinon, ils sont équivalents dans une ifdéclaration.

La seule fois où je peux voir la valeur de l'utilisation des opérateurs non-court-circuit est si le RHS a une sorte d'effet secondaire souhaitable que vous souhaitez voir se produire dans tous les cas. Je ne peux pas penser à un exemple précis où vous voudriez cela, et je ne pense pas que ce soit une bonne pratique, mais c'est la différence.

La réponse philosophique générale est que l'utilisation d'opérateurs au niveau du bit pour les opérateurs booléens est atypique et rend le code plus difficile à lire. En pratique (pour le code en production), un code plus lisible est plus facile à maintenir et donc plus souhaitable.

Pour une utilisation réelle du besoin d'opérateurs de court-circuit, voir des cas tels que:

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

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

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

Ce type d'opérations apparaît fréquemment dans le code du monde réel.

Vous utiliserez des opérateurs au niveau du bit si vous comparez les énumérations Bitmask. Par exemple, vous disposez d'une énumération d'états et d'un objet qui peut se trouver dans plusieurs de ces états. Dans ce cas, vous devrez faire un bit à bit ou assigner plus d'un état à votre objet.

par exemple state = CONNECTED | IN_PROGRESSoù CONNECTED could be 0x00000001etIN_PROGRESS 0x00000010

Pour plus d'informations, consultez la documentation des énumérations d'indicateurs.

un exemple plus simple de tort:

int condA=1, condB=2;

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

ici, vous avez deux conditions, les deux sont non nulles; mais le bit à bit& résultat au niveau est nul.