## Logical XOR operator in C++?

### Question

Is there such a thing? It is the first time I encountered a practical need for it, but I don't see one listed in Stroustrup. I intend to write:

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

But there is no `^^` operator. Can I use the bitwise `^` here and get the right answer (regardless of machine representation of true and false)? I never mix `&` and `&&`, or `|` and `||`, so I hesitate to do that with `^` and `^^`.

I'd be more comfortable writing my own `bool XOR(bool,bool)` function instead.

2016/05/12
1
300
5/12/2016 3:22:36 PM

The `!=` operator serves this purpose for `bool` values.

2009/10/20
547
10/20/2009 7:03:38 PM

Proper manual logical XOR implementation depends on how closely you want to mimic the general behavior of other logical operators (`||` and `&&`) with your XOR. There are two important things about these operators: 1) they guarantee short-circuit evaluation, 2) they introduce a sequence point, 3) they evaluate their operands only once.

XOR evaluation, as you understand, cannot be short-circuited since the result always depends on both operands. So 1 is out of question. But what about 2? If you don't care about 2, then with normalized (i.e. `bool`) values operator `!=` does the job of XOR in terms of the result. And the operands can be easily normalized with unary `!`, if necessary. Thus `!A != !B` implements the proper XOR in that regard.

But if you care about the extra sequence point though, neither `!=` nor bitwise `^` is the proper way to implement XOR. One possible way to do XOR(a, b) correctly might look as follows

``````a ? !b : b
``````

This is actually as close as you can get to making a homemade XOR "similar" to `||` and `&&`. This will only work, of course, if you implement your XOR as a macro. A function won't do, since the sequencing will not apply to function's arguments.

Someone might say though, that the only reason of having a sequence point at each `&&` and `||` is to support the short-circuited evaluation, and thus XOR does not need one. This makes sense, actually. Yet, it is worth considering having a XOR with a sequence point in the middle. For example, the following expression

``````++x > 1 && x < 5
``````

has defined behavior and specificed result in C/C++ (with regard to sequencing at least). So, one might reasonably expect the same from user-defined logical XOR, as in

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

while a `!=`-based XOR doesn't have this property.

2016/11/18

There is another way to do XOR:

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

Which obviously can be demonstrated to work 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;
}
``````
2016/05/12

The XOR operator cannot be short circuited; i.e. you cannot predict the result of an XOR expression just by evaluating its left hand operand. Thus, there's no reason to provide a `^^` version.

2009/10/20

There was some good code posted that solved the problem better than !a != !b

Note that I had to add the BOOL_DETAIL_OPEN/CLOSE so it would work on 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

Use a simple:

``````return ((op1 ? 1 : 0) ^ (op2 ? 1 : 0));
``````
2016/03/18