What is the point of the logical operators in C?

I was just wondering if there is an XOR logical operator in C (something like && for AND but for XOR). I know I can split an XOR into ANDs, NOTs and ORs but a simple XOR would be much better. Then it occurred to me that if I use the normal XOR bitwise operator between two conditions, it might just work. And for my tests it did.

Consider:

int i = 3;
int j = 7;
int k = 8;

Just for the sake of this rather stupid example, if I need k to be either greater than i or greater than j but not both, XOR would be quite handy.

if ((k > i) XOR (k > j))
   printf("Valid");
else
   printf("Invalid");

or

printf("%s",((k > i) XOR (k > j)) ? "Valid" : "Invalid"开发者_StackOverflow);

I put the bitwise XOR ^ and it produced "Invalid". Putting the results of the two comparisons in two integers resulted in the 2 integers to contain a 1, hence the XOR produced a false. I've then tried it with the & and | bitwise operators and both gave the expected results. All this makes sense knowing that true conditions have a non zero value, whilst false conditions have zero values.

I was wondering, is there a reason to use the logical && and || when the bitwise operators &, | and ^ work just the same?

You don't need logical XOR, I have forgotten the SO question, but it's similar to what you're thinking, basically we don't need XOR, it's equivalent to != anyway

FALSE XOR FALSE == FALSE
FALSE XOR TRUE == TRUE
TRUE XOR FALSE == TRUE
TRUE XOR TRUE == FALSE


FALSE != FALSE == FALSE
FALSE != TRUE == TRUE
TRUE != FALSE == TRUE
TRUE != TRUE == FALSE

I'll search my favorites, and paste here the link later...

The bitwise operators do not work "just the same" as the && and || operator. For a start, && and || perform short-circuited evaluation, whereas the the bitwise operators do not. In other words, you can't do something like this with the bitwise operators:

int * p = 0;
(p != 0) && (*p = 1);

because if you said:

(p != 0) & (*p = 1);

both subexpressions would be evaluated, and you would dereference the null pointer.

Bitwise XOR does not work as would a logical XOR when its operands are integer values:

2^4 ? "Valid" : "Invalid"

gives "Valid" but should give "Invalid"

In C arguments of logical operators are treated as Boolean values - anything zero is treated as "false", and anything else (yes, negative values too) are "true". Bitwise ops work on individual bits, and as Neil already noted, are not subject to short-circuit evaluation as logical ops are.

In your example the results are totally valid and expected since bit-wise xor between two ones is zero.

If you want a logical xor operator in C, then you can use this:

#define xor != 0 ^ !!

It works by converting both sides of the expression to booleans and xoring them. You can use it as if you were using && or ||, like this:

if (a xor b)

AFAICT, there aren't any problems with it.