Bitwise negation check - c

Question

I was reading JS manual, and found nice trick, that ~val === (val != -1).
I found it nice, and want to use it in my C code.
Is it portable? I checked on my GNU/Linux box, it work.
EDIT: Seems I asked not too clearly. Of course, I know, there is no === in C.
Question is, are both conditionals
int val;
if (~val) {...}
if (val != -1) {...}
equal?

Answer 1

The following answer was written for the question as it was originally phrased, which led myself and others to think that he was asking whether ~ans and (ans ^ -1) are equivalent.
This trick is not as portable as ~val because it assumes that -1 == 0b111111111..., which is true only on a two's complement machine (granted, that holds for virtually any machine today). It exploits the fact that the xor operation works as a "controlled inverter", flipping each bit in its left operand for which the corresponding right operand bit is one.
However, substituting ~0 for -1 might work.

Answer 2

No, it's not.
First, the operator "===" doesn't exist i C.
Secondly, the comparison "val != -1" returns true (1) or false (0) in C.
What is it you want to accomplish?

Answer 3

val != -1 will either be 1 or 0.
If val = 0, ~0 = 0xFFFFFFFF on a 32 bit machine with 32 bit integer.
If val = 1, ~1 = 0xFFFFFFFE on a 32 bit machine with 32 bit integer.
and so on.
HOW in the world would this be equal to 1 or 0? anything but only for two specific values of 'val'?
According to Aki's statement: you probably meant ~val = val ^= -1.
xor truth table:
--------------------
|A | B | A^B |
--------------------
|0 | 0 | 0 |
--------------------
|0 | 1 | 1 |
--------------------
|1 | 0 | 1 |
--------------------
|1 | 1 | 0 |
--------------------
example: val = 1:
1(val) is represented as : 0000 0000 0000 0000 0000 0000 0000 0001
-1 is represented as: 1111 1111 1111 1111 1111 1111 1111 1111
-------------------------------------------------------------------
(XOR VAL AND -1): 1111 1111 1111 1111 1111 1111 1111 1110
--------------------------------------------------------------------
[negate:0to1 1to0] ~val : 1111 1111 1111 1111 1111 1111 1111 1110
-------------------------------------------------------------------
Since these two are logically equal - and all machines follow logic, this has to work on every machine that stores negative number in 2's complement method.
BTW: 2's complement is 1's complement of a negative number + 1:
hence to store -1:
-1 = negative : 0000 0000 0000 0000 0000 0000 0000 0001
1' = 1s compliment: 1111 1111 1111 1111 1111 1111 1111 1110
2' = 2s compliemnt: 1111 1111 1111 1111 1111 1111 1111 1111
---------------------------------------------------------------

Answer 4

In the context of if (exprA) vs if (exprB),
exprA := ~val,
exprB := val!=-1
they are equal.
In the context of (exprA) and (exprB) evaluating to the same value, the answer is No.
Either
exprA := ~val in which case the equivalent expression is
exprB := val ^ -1, or
exprB := val!=-1, in which case the equivalent expression could be
exprA := !!(~val)
The revised question is different, as (val!=-1) evaluates to either 0 or 1 in numerical values, but if statements can use any non-zero value to represent the condition true.
So the answer depends on the context.