Logischer XOR-Operator in C ++?

Gibt es so etwas? Es ist das erste Mal, dass ich einen praktischen Bedarf dafür habe, aber ich sehe keinen in Stroustrup . Ich habe vor zu schreiben:

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

Es gibt aber keinen ^^Operator. Kann ich ^hier das bitweise verwenden und die richtige Antwort erhalten (unabhängig von der maschinellen Darstellung von wahr und falsch)? Ich mische nie &und &&, oder |und ||, also zögere ich, das mit ^und zu tun ^^.

Ich würde es mir bequemer machen, bool XOR(bool,bool)stattdessen meine eigene Funktion zu schreiben .

Der !=Operator dient diesem Zweck für boolWerte.

Für eine echte logische XOR-Operation funktioniert dies:

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

Beachten !Sie, dass die Werte in Boolesche Werte konvertiert und negiert werden sollen, sodass zwei ungleiche positive Ganzzahlen (jeweils a true) ausgewertet werden false.

Die ordnungsgemäße manuelle logische XOR-Implementierung hängt davon ab, wie genau Sie das allgemeine Verhalten anderer logischer Operatoren ( ||und &&) mit Ihrem XOR nachahmen möchten . Diese Operatoren haben zwei wichtige Eigenschaften: 1) Sie garantieren eine Kurzschlussbewertung, 2) sie führen einen Sequenzpunkt ein, 3) sie bewerten ihre Operanden nur einmal.

Wie Sie verstehen, kann die XOR-Auswertung nicht kurzgeschlossen werden, da das Ergebnis immer von beiden Operanden abhängt. 1 kommt also nicht in Frage. Aber was ist mit 2? Wenn Sie sich nicht für 2 interessieren, dann mit normalisiert (dhbool!= erledigt der Operator ) Werten die Aufgabe von XOR in Bezug auf das Ergebnis. Und die Operanden können bei Bedarf leicht mit unär normalisiert werden !. Somit !A != !Bimplementiert die richtige XOR in dieser Hinsicht.

Aber wenn Sie sich für den zusätzlichen Sequenzpunkt interessieren, auch nicht != noch bitweise ^der richtige Weg, um XOR zu implementieren. Eine Möglichkeit, XOR (a, b) korrekt auszuführen, könnte wie folgt aussehen

a ? !b : b

Dies ist tatsächlich so nah wie möglich daran, ein hausgemachtes XOR "ähnlich" zu ||und zu machen &&. Dies funktioniert natürlich nur, wenn Sie Ihr XOR als Makro implementieren. Eine Funktion funktioniert nicht, da die Sequenzierung nicht auf die Argumente der Funktion angewendet wird.

Jemand könnte jedoch sagen, dass der einzige Grund, an jedem einen Sequenzpunkt zu haben &&und darin ||besteht, die kurzgeschlossene Auswertung zu unterstützen, und XOR daher keinen benötigt. Das macht eigentlich Sinn. Es lohnt sich jedoch, ein XOR mit einem Sequenzpunkt in der Mitte in Betracht zu ziehen. Zum Beispiel der folgende Ausdruck

++x > 1 && x < 5

hat das Verhalten und das spezifizierte Ergebnis in C / C ++ definiert (zumindest in Bezug auf die Sequenzierung). Man könnte also vernünftigerweise dasselbe von benutzerdefiniertem logischem XOR erwarten wie in

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

Ein !=XOR auf Basis hat diese Eigenschaft nicht.

Es gibt eine andere Möglichkeit, XOR auszuführen:

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

Was offensichtlich gezeigt werden kann, funktioniert über:

#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;
}

Der XOR-Operator kann nicht kurzgeschlossen werden. Das heißt, Sie können das Ergebnis eines XOR-Ausdrucks nicht einfach durch Auswerten seines linken Operanden vorhersagen. Daher gibt es keinen Grund, eine ^^Version bereitzustellen .

Es wurde ein guter Code veröffentlicht, der das Problem besser löste als! A! =! B.

Beachten Sie, dass ich BOOL_DETAIL_OPEN / CLOSE hinzufügen musste, damit es unter MSVC 2010 funktioniert

/* 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

Verwenden Sie eine einfache:

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

Ich denke, Sie schreiben einen XOR-Vergleich in 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
}

Beweis

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

Der Beweis ist, dass eine umfassende Untersuchung der Ein- und Ausgänge zeigt, dass in den beiden Tabellen für jeden Eingabesatz das Ergebnis in den beiden Tabellen immer identisch ist.

Daher war die ursprüngliche Frage, wie man schreibt:

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

Die Antwort wäre

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

Oder wenn Sie möchten, schreiben Sie

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

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

Der erste Teil ist A ODER B, welches das Inklusive ODER ist; Der zweite Teil ist NICHT A UND B. Zusammen erhalten Sie A oder B, aber nicht sowohl A als auch B.

Dies liefert den in der nachstehenden Wahrheitstabelle nachgewiesenen XOR.

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

Ich verwende "xor" (es scheint ein Schlüsselwort zu sein; in Code :: Blocks wird es zumindest fett), genauso wie Sie "und" anstelle von &&und "oder" anstelle von verwenden können ||.

if (first xor second)...

Ja, es ist bitweise. Es tut uns leid.

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

Es funktioniert wie definiert. Die Bedingungen sind zu erkennen, ob Sie Objective-C verwenden , das nach BOOL anstelle von bool fragt (die Länge ist unterschiedlich!)