Opérateur logique XOR en C++ ?

Question

Est-ce que ça existe ? C'est la première fois que j'en rencontre le besoin pratique, mais je n'en vois pas la liste. à 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 ^^ opérateur. Puis-je utiliser l'opérateur bitwise ^ ici et obtenir la bonne réponse (quelle que soit la représentation machine du vrai et du faux) ? Je ne mélange jamais & y && o | y || donc j'hésite à le faire avec ^ y ^^ .

Je serais plus à l'aise pour écrire mes propres bool XOR(bool,bool) à la place.

Answer 1

El != sert à cette fin pour bool valeurs.

Answer 2

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

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

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

Answer 3

Manuel approprié logique La mise en œuvre de XOR dépend du degré d'imitation du comportement général des autres opérateurs logiques ( || y && ) avec votre XOR. Il y a deux choses importantes à propos de ces opérateurs : 1) ils garantissent une évaluation en court-circuit, 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 puisque le résultat dépend toujours des deux opérandes. Le 1 est donc hors de question. Mais qu'en est-il de 2 ? Si vous ne vous préoccupez pas de 2, alors avec une évaluation normalisée (c.-à-d., une évaluation XOR), il est possible d'obtenir un résultat qui dépend des deux opérandes. bool ) opérateur de valeurs != fait le travail de XOR en termes de résultat. Et les opérandes peuvent être facilement normalisés avec unary ! si nécessaire. Ainsi, !A != !B implémente le XOR approprié à cet égard.

Mais si vous vous souciez du point de séquence supplémentaire, ni l'un ni l'autre != ni par bit ^ est la façon correcte d'implémenter XOR. Une façon possible de faire XOR(a, b) correctement pourrait ressembler à ceci

a ? !b : b

C'est en fait ce qui se rapproche le plus de la fabrication d'un XOR fait maison "semblable" à || y && . Cela ne fonctionnera, bien sûr, que si vous implémentez votre XOR comme une macro. Une fonction ne fera pas l'affaire, puisque 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 à chaque fois && y || est de supporter l'évaluation court-circuitée, et donc XOR n'en a pas besoin. Cela a du sens, en fait. Pourtant, il est intéressant 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). On peut donc raisonnablement s'attendre à ce que la même chose se produise avec les fonctions logique XOR, comme dans

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

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

Answer 4

Il y a une autre façon de faire le 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;
}

Answer 5

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 en évaluant simplement son opérande gauche. Par conséquent, il n'y a aucune raison de fournir une fonction de type ^^ version.