Quel est l’intérêt des opérateurs logiques par rapport aux opérateurs au niveau des bits

Étant donné que cette déclaration est une opération logique

((a > 5) && (b > 4)) 

Et cette déclaration est bitwise-operation

  ((a > 5) & (b > 4)) 

Les deux déclarations ci-dessus ne sont pas équivalentes.

Parce que (a > 5) est un élément de {0,1}

Alors, pourquoi avons-nous besoin d’ logical operators & bitwise-operation ?

Edit : merci pour tous les commentaires. En ce qui concerne le comportement de court-circuit des opérateurs logiques, je ne souhaite pas ce comportement. J’écris du code pour un GPU où les twigs dégradent les performances: un court-circuit produit deux twigs au lieu d’une dans le code.

Pour les comparaisons numériques en C, dans le cas où un court-circuit n’est pas nécessaire, il semble que les comportements logique et binary soient identiques. Dans mon cas, les opérations au niveau des bits sont plus rapides que la logique.

Je m’excuse de ne pas avoir mis ces détails dans la publication originale.

Je pense que non, prenons cet exemple (0b – signifie binary):

 a = 0b00000010 b = 0b00000100 

Or, ni a ni b vaut 0. Mais a & b == 0 (en raison de la façon dont AND est défini au niveau des bits).

Toutefois, a && b != 0 (car pour AND logique, le résultat est 0 si au moins un opérande est 0, ce n’est pas le cas avec a et b ci-dessus).


Il existe également une évaluation de court-circuit. Si, dans && opérande gauche est 0, celui de droite ne sera pas évalué car le résultat est certainement 0 (par exemple, comme déjà mentionné 0 && x == 0 quelle que soit la valeur de x ).

  • Les opérateurs logiques convertissent leurs opérandes en bool avant de les combiner et le résultat d’un opérateur logique est également bool tout le temps. Les opérateurs au niveau des bits ne le font pas (toutefois, dans le cas d’opérandes bool, cela ne fait aucune différence entre les deux types d’opérateurs).
  • Les opérateurs logiques peuvent être utilisés sur de nombreux types d’opérandes pouvant être convertis en bool, tandis que les opérateurs au niveau des bits ne fonctionnent que sur quelques types dans des cas spécifiques et que la sortie des opérateurs au niveau des bits est typée (pas toujours bool).
  • les opérateurs logiques sont des raccourcis. Par exemple, dans le cas de && cela signifie: si le premier opérande est false, le second opérande n’est même pas évalué car l’expression entière (false && quelque chose) est déjà false quelle que soit la valeur du second opérande.

Les opérateurs de raccourci logiques sont souvent exploités dans les cas suivants:

 // If mypointer is NULL, then mypointer->is_whatever() // isn't evaluated so it doesn't cause a NULL pointer crash. if (mypointer && mypointer->is_whatever()) { // do my thing } 

Les opérateurs logiques doivent comparer plusieurs valeurs avec vraisemblance.

Par exemple, vous utilisez l’opérateur && pour voir si deux valeurs sont toutes deux true .


Les opérateurs binarys servent à l’isolation et à la modification de bits dans une valeur.

Par exemple, pour désactiver tous les bits d’une valeur de 8 bits sauf un, procédez comme suit:

 val & 00100000 

Dans l’exemple ci-dessus, le 6ème bit (basé sur 1) ou le 5ème (basé sur 0) est conservé tel quel et les autres bits sont désactivés.


Les deux types d’opérateurs sont similaires en ce sens qu’ils donnent soit 0, soit 1.

Par exemple, prenez ceux-ci:

 1 || 0 

Ce qui précède donnerait 1 car l’une des valeurs est égale à 1 . Cependant, si nous passons de l’opérateur à && , cela donnera 0.

Sur tous les opérateurs que vous essayez, ils donneront tous 1 ou 0 , true ou false . En effet, il n’existe pas d’expression évaluant “comme” vrai “ou” peut-être faux “.

Et je pense que la raison pour laquelle un opérateur sage “produit” toujours 1 ou 0 est assez explicite: peu à peu ; un bit est 1 ou 0.

Les expressions utilisées comme booléens n’ont pas toutes la valeur 0 ou 1; alors que 0 est traité comme faux, tout ce qui est différent de 0 est traité comme vrai. Ainsi, par exemple, 1 && 2 serait vrai, mais pas 1 & 2 , même si 1 et 2 seraient considérés comme vrais.

En outre, comme d’autres l’ont fait remarquer, les opérateurs logiques n’évaluent pas la seconde expression si la première suffit à déterminer la valeur globale (“court-circuitage”), ce qui ne peut évidemment pas être réalisé avec la version au niveau du bit (ainsi, pas aussi souvent). ; 0 & ? Sera 0 quoi qu’il en soit, et n’aura donc pas besoin d’être évalué pour obtenir la valeur finale, mais & ne fonctionne pas de cette façon).