C ++中的逻辑XOR运算符？

有这样的事吗？这是我第一次遇到实际需求，但我看不到Stroustrup中列出的需求。我打算写：

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

但是没有^^运算符。我可以在^这里使用按位运算，并得到正确的答案吗（不管机器是对还是错）。我从不混合&和&&，或|和||，所以我犹豫着用^和^^。

我会更愿意编写自己的bool XOR(bool,bool)函数。

该!=运营商服务于这一目的的bool值。

对于真正的逻辑XOR操作，这将起作用：

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

请注意，!这里存在将值转换为布尔值并取反的方法，因此两个不相等的正整数（每个a true）的求和结果为false。

正确的手动逻辑 XOR实现取决于您希望与XOR模仿其他逻辑运算符（||和&&）的一般行为的紧密程度。这些运算符有两个重要的方面：1）保证短路评估，2）引入顺序点，3）仅评估操作数一次。

如您所知，XOR评估不能短路，因为结果始终取决于两个操作数。所以1是毫无疑问的。但是2呢？如果您不在乎2，则使用归一化（即bool）值，运算符!=将根据结果执行XOR的工作。!如果需要，可以很容易地用一元对操作数进行标准化。从而!A != !B在这方面实施适当的XOR。

但是，如果您关心额外的序列点，则实现XOR的正确方法都不!=是按位^进行。正确执行XOR（a，b）的一种可能方法如下所示

a ? !b : b

实际上，这与使自制XOR与||和“相似”非常接近&&。当然，仅当您将XOR实现为宏时，这才起作用。函数不会这样做，因为排序将不适用于函数的参数。

也许有人会说，在每个&&和上都有一个序列点的唯一原因||是为了支持短路评估，因此XOR不需要一个。实际上，这是有道理的。但是，值得考虑的是在中间有序列点的XOR。例如，以下表达式

++x > 1 && x < 5

已在C / C ++中定义了行为和特定的结果（至少在排序方面）。因此，可以合理地期望用户定义的逻辑 XOR 具有相同的功能，例如

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

而!=基于XOR的不具有此属性。

还有另一种执行XOR的方法：

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

显然可以通过以下方式证明其有效：

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

XOR运算符不能短路；即，您不能仅通过评估左操作数来预测XOR表达式的结果。因此，没有理由提供^^版本。

发布了一些不错的代码，比！a！=！b更好地解决了问题。

请注意，我必须添加BOOL_DETAIL_OPEN / CLOSE，这样它才能在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

使用简单：

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

我认为这是您在C ++中编写XOR比较的方式：

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
}

证明

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

证明是，对输入和输出的详尽研究表明，在两个表中，对于每个输入集，结果始终在两个表中相同。

因此，最初的问题是如何写：

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

答案是

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

或者，如果您愿意，写

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

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

第一部分是A OR B，这是“包含” OR；第二部分不是A和B。您在一起会得到A或B，但不会同时得到A和B。

这将提供在下面的真值表中证明的XOR。

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

我使用“ xor”（似乎是一个关键字；在Code :: Blocks中至少它变为粗体），就像您可以使用“ and”代替&&和“ or”代替一样||。

if (first xor second)...

是的，这是按位的。抱歉。

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

它按定义工作。有条件的条件是检测您是否使用的是Objective-C，它是要BOOL而不是bool（长度不同！）