XOR 或 NOT 用于否定变量

Question

I was wandering what is better/preferred practice while performing negation of a boolean variable, XOR or NOT?

bool someVariable;

I even don't know why, but I always use XOR, I just like it more:

someVariable ^= true;

However, the more obvious way is to use NOT:

someVariable = !someVariable;

I am probably using the first way so I don't need to type the name of a variable twice, reducing possibility of some errors, typos, etc. It is also less characters to type if the variable is longer than a few chars :)

However, the first way is not really obvious on the first look for anybody who do not use this trick.

Also, the XOR is IMHO more readable because you are sure that the negation is applied on the variable. The NOT could be with two different variables and it is easy to miss if the names look similar:

affect = !effect;

What are advantages and disadvantages of those two approaches? What should I use? Or it is only matter of personal preference?

Answer 1

Semantics

Always go for semantically reasonable code. someVariable ^= true; is correct for sure, but might require thinking what it does (and why) to readers unused to this version of negating.

someVariable = !someVariable; is very explicit about what it is doing: it negates someVariable without any possibility nor requirement to interpret it.

Further Effects

Furthermore it might be that some code analysis software can do whatever it might be able to (optimization, error analysis, ...) with the ! -version, but fail at the rather unexpected ^ -statement. During compilation, it might happen that the XOR-version is slower as (depending on the platform) can require to load true into another register before performing the operation. This effect is negligible in probably all cases, but the additional register used might be not.

Answer 2

IMHO you should use the NOT approach because its way more readable and one can instantly understand whats going on.

I am probably using the first way so I don't need to type the name of a variable twice, reducing possibility of some errors, typos, etc. It is also less characters to type if the variable is longer than a few chars :)

If you are using an IDE, you wont be typing more than a couple of chars either way :)

However, the first way is not really obvious on the first look for anybody who do not use this trick.

Absolutely true. I've never seen this before.

What should I use? Or it is only matter of personal preference?

Well, code is written once, but read many times, so you should go with the option that most people find more readable, and IMHO, its the "NOT" approach. Reserve the bitwise operators for bitwise operations:)

Answer 3

NOT ( ! ) has a few advantages:

1. it is more readable for most of people who will ever need to modify your code.
2. it is usually faster than xor (which gets two arguments while not takes only one)

3. it doesn't take less to type when you use short variable names:

   Eg a =! a a =! a is shorter than a ^= true

Answer 4

NOT because it is more readable and because it actually communicates what you intend to do. You want to negate a logical value, not perform an XOR operation.

Answer 5

One benefit of the XOR method I'd like to point out is that you don't need to hard-code whether negation takes place.

bool isNegated;
//... later
return value ^ isNegated;

over

return isNegated ? !value : value;    

I still use the latter for readability when I don't mind introducing a branch.