c++中的逻辑异或运算符?

有这样的东西吗?这是我第一次遇到对它的实际需求，但我在Stroustrup中没有看到它的列表。我打算写:

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

但是没有^^操作符。我可以使用这里的位^并得到正确的答案(不管机器表示的是真还是假)吗?我从不把&和&&混在一起，或者|和||混在一起，所以我不太愿意把^和^^混在一起。

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

当前回答

以下是我认为在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
}

证明

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

2016-09-13 15:00:50

其他回答

异或运算符不能短路;也就是说，你不能仅仅通过计算一个XOR表达式的左操作数来预测它的结果。因此，没有理由提供^^版本。

2009-10-20 19:02:53

=运算符用于bool值。

2009-10-20 19:03:38

有一些好的代码比!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

2012-09-06 02:46:47

正确的手动逻辑异或实现取决于您希望用异或模拟其他逻辑运算符(||和&&)的一般行为的程度。关于这些操作符有两个重要的事情:1)它们保证短路计算，2)它们引入序列点，3)它们只计算操作数一次。

正如您所理解的，异或求值不能被短路，因为结果总是取决于两个操作数。所以1是不可能的。那么2呢?如果你不关心2，那么对于规范化的(即bool)值，operator !=在结果方面完成XOR的工作。如果需要，操作数可以很容易地用unary !规范化。因此，A != !B在这方面实现了适当的异或。

但是如果你关心额外的序列点，无论是!=还是位^都不是实现异或的正确方法。正确执行异或(a, b)的一种可能方法如下所示