Is !x the same as ~(x) in C?

!x is a logical non-operator, only concerned about whether x is zero, 0 becomes 1, otherwise it becomes 0; while ~(x) is a bit inversion operator, inverting each binary bit of x, 0 becomes 1, and 1 becomes 0, the result may involve complement calculation.

In C language !x and ~(x) are different. Although they both seem to be doing some kind of "reversal", the bit-level details of their effects are actually very different from the results. This is not as easy as fooling around with the authenticity.

Let’s talk about it first !x . This is a logical non-operator, it only cares whether x is zero. If x is zero, !x returns 1 (true); otherwise, !x returns 0 (false). Note that the zero mentioned here refers to the numerical value zero, not a null pointer or other strange things. This thing only makes sense for boolean values ​​(or expressions that can be implicitly converted to boolean values), and it does not care about the binary representation of x at all.

Let’s take a look at ~(x) . This is the bit inversion operator, which inverts every binary bit of x . 0 becomes 1, 1 becomes 0. This is the real "reversal". For example, if x is 10 (binary 1010), then ~(x) is -11 (the two's complement is expressed as 111111111111111111111111111111111111111111111110101, assuming it is a 32-bit integer). You see, the result is completely different. This involves complement representation, where the binary representation of an integer and the binary representation of its negative number is converted by inversely adding one.

So, if you want to determine whether a variable is zero, !x is your good partner; but if you need to invert each bit of the variable, then ~(x) is your choice. Don't mess it up. Although both of these two things have exclamation marks or wavy lines, they are completely different operators and act on different levels, and the results are naturally very different.

Going deeper, from a performance point of view, !x is usually more efficient than ~(x) , because !x only needs to check if x is zero, while ~(x) requires operations on each bit. The compiler may optimize, but in principle !x has a smaller computational overhead.

There are some other points to note:

• The return value of !x is a boolean value (0 or 1), while the return value of ~(x) is an integer, the same type as x .
• For unsigned integers, the result of ~(x) is the bit inversion result of the integer within the range of this type. For signed integers, the result involves the calculation of complement, which may cause the result to appear inconsistent with the intuition. This is a pit that many beginners are prone to step on. You must understand the principle of complement code to avoid these misunderstandings.

Finally, remember: the code should be written clearly and easily understandable, and don’t sacrifice readability in pursuit of so-called “conciseness”. Select the right operator and write clear comments to make your code easier to understand and maintain. This is the real way to programming.

The above is the detailed content of Is !x the same as ~(x) in C?. For more information, please follow other related articles on the PHP Chinese website!