Sur le dessus de ma tête, je ne peux penser à une seule langue que j'ai utilisée qui avait une exclusivité logique ou un opérateur, mais tous ont logique et bitwise regarder autour de ce qui est que je pouvais trouver, c'est que exclusif ou ne peut pas être court-circuité, une version logique serait donc inutile, ce que je ne vois vraiment pas d'être le cas. La raison pour laquelle il est venu à mon attention que la plupart des langues manquent que c'est que j'en avais besoin (j'utilisais Ruby, alors j'ai écrit une méthode pour convertir un entier à un booléen, puis utiliser Bitwise Xor, qui agit sur les booléens) . P> Utilisation de BitWise Xor ne fonctionne pas non plus, car cela donnera un résultat différent. P> et code> et ou Code> Les opérateurs. 0b0001 ^ 0b1000 = 0b1001 (True)
0b0001 XOR 0b1000 = False
// Where ^ is bitwise exclusive or and XOR is logical exclusive or
// Using != (not equal to) also doesn't work
0b0001 != 0b1000 = True
6 Réponses :
La seule raison pour laquelle je peux penser est que l'opération est relativement rare. Je ne vois pas pourquoi quelque chose comme ^^ ne pouvait pas y être assigné cependant, peut-être que les personnes qui conçoivent des langues veulent éviter l'encombrement de l'opérateur.
Quoiqu'il s'agit d'inutile car il ne peut pas être court-circuité, dans de nombreuses langues fortement typées, vous ne pouvez pas utiliser l'opérateur Bitwise Xor pour comparer les booléens sans couler, auquel cas même un circuit non court Logical Xor aurait un sens à avoir.
Probablement parce que Xor n'est pas couramment nécessaire comme opérateur logique, et vous pouvez le faire presque aussi facilement que ceci:
// foo xor bar (foo & !bar) || (bar & !foo) // or like this (assuming foo and bar are booleans) !(foo==bar) // assume boleans that can be cast as integers with true=1 and false=0 // foo XOR bar XOR baz XOR alice ((int)foo + (int)bar + (int)baz + (int)alice)&0b1
Cela sera compliqué pour trois ou quatre tests.
Oui, mais ce n'est qu'une de ces choses qui sont assez rares pour que les concepteurs de langue ne soient pas fidèles.
Près de chaque langue a un Xor logique. Le symbole qu'ils utilisent pour cela varie, mais peu importe le symbole, la plupart des gens le prononcent "non égaux".
Edit: Pour ceux qui en doute, Code de test pour trois variables: P>
#include <iostream>
int main() {
for (int i=0; i<2; i++)
for (int j=0; j<2; j++)
for (int k=0; k<2; k++) {
std::cout << "\n!=" << (i!=j!=k);
std::cout << "\t^ " << (i^j^k);
}
return 0;
}
Si vous ne pouvez pas garantir un contexte booléen, cela demande des bugs subtils.
La plupart des langues ont un xor bitwise, mais pas un logique un. "Pas égal" fonctionne la même chose dans le cas des opérandes de remorquage, mais je ne pense pas a! = B! = C est équivalent à un XOR B XOR c.
Et l'opération inverse est équivalence ou simplement égale .
@CRAIG MCQUEN: La seule salle de désaccord possible est de savoir si les bugs seront (nécessairement) être subtils!
@Madcoder, ! = est un XOR lorsque les deux opérandes sont booléennes. Et oui, a! = B! = C est exactement équivalent à A xor b xor c si tous les opérandes sont booléennes.
Oui, je me trompe. Néanmoins, avoir un opérateur XOR explicite pourraient aborder les préoccupations de Craig car les opérandes pouvaient être distribuées automatiquement aux booléens.
@MadCoder: Il y a sans aucun doute des circonstances sous lesquelles il serait pratique. OTOH, je peux penser à beaucoup d'autres opérateurs que je suis sûr que j'utiliserais beaucoup plus souvent.
Ajout d'un exemple de comment ! = n'est pas un remplaçant pour XOR logique. Curieusement, c'est le même exemple qu'avant, sauf que je mets ! = là-bas.
@Jeffrey: Oui, c'est un boolean Xor, vous devez donc vous assurer que les valeurs sont booléennes avant de les appliquer. Puisque les inverser n'a pas d'importance, vous pouvez utiliser ! A! =! B ;
Que voulez-vous dire par "Opérateur XOR logique"? Je ne sais pas quel résultat attendez-vous de vos exemples, mais voici ma réponse:
L'inégalité est un Xor logique. Puisque vous avez déjà la version Bitwise Xor, vous n'avez pas besoin d'un opérateur spécial pour le logique. A (xor logique) B est identique à celui bool (a)! = bool (b)
OK, vous recherchez donc un sage exclusif exclusif-ou versus A bit exclusif exclusif-ou. Il semble que vous recherchiez quelque chose qui fonctionnera sur un octet comme "ON" ou "OFF", comme pensent que les octets sont "0" ou "non nul", puis xor eux. Cela ressemble vraiment à vous chercher à compresser chaque octet en un seul bit indiquant vrai ou faux. Donc, cela sonne comme si vous voulez (A! = 0) ^ (b! = 0) comme pour pourquoi ce n'est pas dans chaque langue ... que je ne peux pas vraiment répondre. Cependant, ce n'est pas tout ce qui est difficile à mettre en œuvre avec les blocs de construction de Bitwise XOR disponibles dans chaque langue et aucune langue n'offre toutes les fonctionnalités possibles - elles offrent simplement suffisamment pour vous permettre de construire la fonctionnalité étendue dont vous pourriez avoir besoin. Oh, et si c'était un problème assez populaire, vous vous attendriez à voir des bibliothèques ou des macros partout à la place; Bien que je n'ai peut-être pas eu une recherche suffisante de tels libs / code, je n'ai trouvé aucun moi-même, indiquant que l'exigence est triviale à écrire ou à une nécessité de niche.
Je pense! A ^! B travaille aussi. En particulier, cela fonctionne dans Ruby comme ! X est un bool
Vous pouvez également écrire Vous ne trouvez probablement pas XOR logique dans les langages de programmation car:
! A ^! B pour obtenir le même effet qu'un XOR logique.
Dans votre deuxième exemple, il suppose une langue qui utilise non-zéro pour vrai.
Pouvez-vous donner un exemple de la façon dont votre XOR logique diffère de non égal?
Le réel ici est "Pourquoi essayez-vous d'utiliser des opérateurs logiques sur des valeurs non booléennes?" C'est une pratique de programmation sémantiquement invalide et de mauvaise programmation pour commencer.
Ce que Rbarreyoung a dit. Vous avez un opérateur XOR bitwise (^) à utiliser avec quoi que ce soit utilisé comme bitmap. Vous avez un opérateur XOR logique (! =) À utiliser avec des valeurs booléennes. Vous avez des moyens de créer des valeurs booléennes à partir d'autres types. Qu'as-tu besoin de plus?
Il est donc mauvais pratique d'utiliser || ou && sur des valeurs non booléennes?