Opérateur XOR logique en C ++?

Existe-t-il une telle chose? C'est la première fois que j'en rencontre un besoin pratique, mais je n'en vois aucun répertorié dans Stroustrup . J'ai l'intention d'écrire:

// Detect when exactly one of A,B is equal to five.
return (A==5) ^^ (B==5);

Mais il n'y a pas d' ^^opérateur. Puis-je utiliser le bit ^ici et obtenir la bonne réponse (quelle que soit la représentation machine de vrai et de faux)? Je ne mélange jamais &et &&, ou |et ||, j'hésite donc à le faire avec ^et ^^.

Je préfèrerais plutôt écrire ma propre bool XOR(bool,bool)fonction.

L' !=opérateur sert cet objectif pour les boolvaleurs.

Pour une véritable opération XOR logique, cela fonctionnera:

if(!A != !B) {
    // code here
}

Notez que !sont là pour convertir les valeurs en booléens et les annuler, de sorte que deux entiers positifs inégaux (chacun a true) seraient évalués false.

L' implémentation manuelle XOR logique appropriée dépend de la façon dont vous souhaitez imiter le comportement général des autres opérateurs logiques ( ||et &&) avec votre XOR. Il y a deux choses importantes à propos de ces opérateurs: 1) ils garantissent l'évaluation des courts-circuits, 2) ils introduisent un point de séquence, 3) ils évaluent leurs opérandes une seule fois.

L'évaluation XOR, comme vous le comprenez, ne peut pas être court-circuitée car le résultat dépend toujours des deux opérandes. Donc 1 est hors de question. Mais qu'en est-il de 2? Si vous ne vous souciez pas de 2, alors avec des boolvaleurs normalisées (c'est-à-dire ), l'opérateur !=fait le travail de XOR en termes de résultat. Et les opérandes peuvent être facilement normalisés avec unaire !, si nécessaire. Implémente ainsi !A != !Ble XOR approprié à cet égard.

Mais si vous vous souciez du point de séquence supplémentaire, !=ni le bit ni le bit ^n'est la bonne façon d'implémenter XOR. Une façon possible de faire XOR (a, b) correctement pourrait se présenter comme suit

a ? !b : b

Ceci est en fait aussi proche que possible de la fabrication d'un XOR maison "similaire" à ||et &&. Cela ne fonctionnera, bien sûr, que si vous implémentez votre XOR en tant que macro. Une fonction ne fonctionnera pas, car le séquencement ne s'appliquera pas aux arguments de la fonction.

Quelqu'un pourrait dire cependant que la seule raison d'avoir un point de séquence à chacun &&et ||est de prendre en charge l'évaluation en court-circuit, et donc XOR n'en a pas besoin. Cela a du sens, en fait. Pourtant, il vaut la peine d'envisager d'avoir un XOR avec un point de séquence au milieu. Par exemple, l'expression suivante

++x > 1 && x < 5

a un comportement défini et un résultat spécifique en C / C ++ (en ce qui concerne le séquençage au moins). Donc, on peut raisonnablement s’attendre à la même chose de la part du XOR logique défini par l’utilisateur , comme dans

XOR(++x > 1, x < 5)

tandis qu'un !=XOR basé sur n'a pas cette propriété.

Il existe une autre façon de faire XOR:

bool XOR(bool a, bool b)
{
    return (a + b) % 2;
}

Ce qui peut évidemment être démontré pour fonctionner via:

#include <iostream>

bool XOR(bool a, bool b)
{
    return (a + b) % 2;
}

int main()
{
    using namespace std;
    cout << "XOR(true, true):\t" << XOR(true, true) << endl
         << "XOR(true, false):\t" << XOR(true, false) << endl
         << "XOR(false, true):\t" << XOR(false, true) << endl
         << "XOR(false, false):\t" << XOR(false, false) << endl
         << "XOR(0, 0):\t\t" << XOR(0, 0) << endl
         << "XOR(1, 0):\t\t" << XOR(1, 0) << endl
         << "XOR(5, 0):\t\t" << XOR(5, 0) << endl
         << "XOR(20, 0):\t\t" << XOR(20, 0) << endl
         << "XOR(6, 6):\t\t" << XOR(5, 5) << endl
         << "XOR(5, 6):\t\t" << XOR(5, 6) << endl
         << "XOR(1, 1):\t\t" << XOR(1, 1) << endl;
    return 0;
}

L'opérateur XOR ne peut pas être court-circuité; c'est-à-dire que vous ne pouvez pas prédire le résultat d'une expression XOR simplement en évaluant son opérande de gauche. Il n'y a donc aucune raison de fournir une ^^version.

Un bon code publié a résolu le problème mieux que! A! =! B

Notez que j'ai dû ajouter le BOOL_DETAIL_OPEN / CLOSE pour que cela fonctionne sur MSVC 2010

/* From: http://groups.google.com/group/comp.std.c++/msg/2ff60fa87e8b6aeb

   Proposed code    left-to-right?  sequence point?  bool args?  bool result?  ICE result?  Singular 'b'?
   --------------   --------------  ---------------  ---------- ------------  -----------  -------------
   a ^ b                  no              no             no          no           yes          yes
   a != b                 no              no             no          no           yes          yes
   (!a)!=(!b)             no              no             no          no           yes          yes
   my_xor_func(a,b)       no              no             yes         yes          no           yes
   a ? !b : b             yes             yes            no          no           yes          no
   a ? !b : !!b           yes             yes            no          no           yes          no
   [* see below]          yes             yes            yes         yes          yes          no
   (( a bool_xor b ))     yes             yes            yes         yes          yes          yes

   [* = a ? !static_cast<bool>(b) : static_cast<bool>(b)]

   But what is this funny "(( a bool_xor b ))"? Well, you can create some
   macros that allow you such a strange syntax. Note that the
   double-brackets are part of the syntax and cannot be removed! The set of
   three macros (plus two internal helper macros) also provides bool_and
   and bool_or. That given, what is it good for? We have && and || already,
   why do we need such a stupid syntax? Well, && and || can't guarantee
   that the arguments are converted to bool and that you get a bool result.
     Think "operator overloads". Here's how the macros look like:

   Note: BOOL_DETAIL_OPEN/CLOSE added to make it work on MSVC 2010
  */

#define BOOL_DETAIL_AND_HELPER(x) static_cast<bool>(x):false
#define BOOL_DETAIL_XOR_HELPER(x) !static_cast<bool>(x):static_cast<bool>(x)

#define BOOL_DETAIL_OPEN (
#define BOOL_DETAIL_CLOSE )

#define bool_and BOOL_DETAIL_CLOSE ? BOOL_DETAIL_AND_HELPER BOOL_DETAIL_OPEN
#define bool_or BOOL_DETAIL_CLOSE ? true:static_cast<bool> BOOL_DETAIL_OPEN
#define bool_xor BOOL_DETAIL_CLOSE ? BOOL_DETAIL_XOR_HELPER BOOL_DETAIL_OPEN

Utilisez un simple:

return ((op1 ? 1 : 0) ^ (op2 ? 1 : 0));

Voici comment je pense que vous écrivez une comparaison XOR en C ++:

bool a = true;   // Test by changing to true or false
bool b = false;  // Test by changing to true or false
if (a == !b)     // THIS IS YOUR XOR comparison
{
    // do whatever
}

Preuve

XOR TABLE
 a   b  XOR
--- --- ---
 T   T   F
 T   F   T
 F   T   T
 F   F   F

a == !b TABLE
 a   b  !b  a == !b
--- --- --- -------
 T   T   F     F
 T   F   T     T
 F   T   F     T
 F   F   T     F

La preuve en est qu'une étude exhaustive des entrées et sorties montre que dans les deux tableaux, pour chaque ensemble d'entrées le résultat est toujours identique dans les deux tableaux.

Par conséquent, la question initiale était de savoir comment écrire:

return (A==5) ^^ (B==5)

La réponse serait

return (A==5) == !(B==5);

Ou si vous le souhaitez, écrivez

return !(A==5) == (B==5);

(A || B) && !(A && B)

La première partie est A OR B, qui est le OU inclusif; la deuxième partie est, PAS A ET B. Ensemble, vous obtenez A ou B, mais pas à la fois A et B.

Cela fournira le XOR prouvé dans la table de vérité ci-dessous.

|-----|-----|-----------|
|  A  |  B  |  A XOR B  |
|-----|-----|-----------|
|  T  |  T  |   False   |
|-----|-----|-----------|
|  T  |  F  |   True    |
|-----|-----|-----------|
|  F  |  T  |   True    |
|-----|-----|-----------|
|  F  |  F  |   False   |
|-----|-----|-----------|

J'utilise "xor" (il semble que ce soit un mot-clé; au moins dans Code :: Blocks, il devient gras) tout comme vous pouvez utiliser "et" au lieu de &&et "ou" à la place de ||.

if (first xor second)...

Oui, c'est au niveau du bit. Désolé.

#if defined(__OBJC__)
    #define __bool BOOL
    #include <stdbool.h>
    #define __bool bool
#endif

static inline __bool xor(__bool a, __bool b)
{
    return (!a && b) || (a && !b);
}

Cela fonctionne comme défini. Les conditions sont de détecter si vous utilisez Objective-C , qui demande BOOL au lieu de bool (la longueur est différente!)