(x ^ 0x1) = 0是什么意思？

小开

^是按位 XOR操作
0x1是十六进制的 1
x ^ 0x1将反转 x的最后一位(如果您不清楚，请参考上面链接中的 XOR 真值表)。

因此，如果 x大于1或者 x的最后一位为0，则条件 (0 != ( x ^ 0x1 ))为真。只剩下 x = = 1作为条件为 false 的值。所以它相当于

if (x != 1)

另外，我还要补充一点，实现这样一个简单条件的方法真是糟糕透顶。别这样。如果你必须编写复杂的代码，请留言。我求你了。

小开

^运算符是按位的 xor。而 0x1是数字 1，以十六进制常量表示。

因此，x ^ 0x1计算得到的新值与 x相同，但是翻转了最低有效位。

这段代码只是以一种非常复杂和晦涩的方式将 x 与1进行比较。

小开

最佳答案

异或操作(x ^ 0x1)反转位0。所以这个表达式实际上意味着: 如果 x 的0位是0，或者任何 x 的其他位是1，那么这个表达式就是真。

反之，如果 x = = 1，则表达式为 false。

所以这个测试和:

if (x != 1)

因此(可以说)是不必要的混淆。

小开

它检查 x实际上不是 0x1... ... 只有当 x是 0x1时，xoring x和 0x1才会得到0... ... 这是汇编语言中常用的老把戏

小开

^是 c中的按位 xor operator。在您的例子中，x 用1表示。例如，x的值为10，那么 10d ^ 1d ===> 1010b ^ 0001b = 1011b, 1011b == 11d的条件就成为真。

小开

它是独占 OR (XOR)操作符。要理解它是如何工作的，可以运行这个简单的代码

    std::cout << "0x0 ^ 0x0 = " << ( 0x0 ^ 0x0 ) << std::endl;
std::cout << "0x0 ^ 0x1 = " << ( 0x0 ^ 0x1 ) << std::endl;
std::cout << "0x1 ^ 0x0 = " << ( 0x1 ^ 0x0 ) << std::endl;
std::cout << "0x1 ^ 0x1 = " << ( 0x1 ^ 0x1 ) << std::endl;

输出将是

0x0 ^ 0x0 = 0
0x0 ^ 0x1 = 1
0x1 ^ 0x0 = 1
0x1 ^ 0x1 = 0

所以这个表达

0 != ( x ^ 0x1 )

只有当 x! = 0x1时才等于真。

它不会改变 x 本身。它只检查 x 是等于0还是1。这个表达式可以改为

if ( x != 0x1 )

小开

Xor (独占或)运算符最常用于反转一个或多个位。这个操作是询问一个比特是否是一个比特，这会导致下面的真值表(A 和 B 是输入，Y 是输出) :

A    B    Y
0    0    0
0    1    1
1    0    1
1    1    0

现在这段代码的目的似乎是检查最后一位是否正确，其他位是否正确，这等于 if ( x != 1 )。这种模糊方法的原因可能是因为以前的位操作技术已经被使用过，并且可能在程序的其他地方也被使用过。

小开

这可能看起来是一种过于简单的解释，但如果有人想慢慢来，可以这样解释:

^是 c、 c + + 和 c # 中的按位异或(XOR)运算符。

按位异或接受两个长度相等的位模式，并执行对每对对应位的逻辑排他或运算。

独占 OR 是一种逻辑操作，每当输入不同(一个为真，另一个为假)。

一个 x 或者 b的真相表:

a           b        a xor b
----------------------------
1           1           0
1           0           1
0           1           1
0           0           0

因此，让我们在二进制级别上演示 0 == ( x ^ 0x1 )表达式:

             what? xxxxxxxx (8 bits)
xor 00000001 (hex 0x1 or 0x01, decimal 1)
gives 00000000
---------------------------
the only answer is 00000001

所以:

   0 == ( x ^ 0x1 )    =>    x == 1
0 != ( x ^ 0x1 )    =>    x != 1

小开

XOR 在 C # 标志枚举中很有用。要从枚举值中移除单个标志，需要使用 xor 操作符(参考给你)

例如:

[Flags]
enum FlagTest { None 0x0, Test1 0x1, Test2 0x2, Test3 0x4}


FlagTest test = FlagTest.Test2 | FlagTest.Test3;
Console.WriteLine(test); //Out: FlagTest.Test2 | FlagTest.Test3
test = test ^ FlagTest.Test2;
Console.WriteLine(test); //Out: FlagTest.Test3

小开

按位测试似乎是一种有意的混淆，但是如果底层数据是来自 IBM 大型机系统的公司数据，那么可能只是编写代码以反映原始文档。IBM 数据格式可以追溯到20世纪60年代，为了节省存储空间，它经常将标志编码为单个位。在修改格式时，会在现有记录的末尾添加标志字节，以保持向后兼容性。例如，SMF 记录的文档可能会显示汇编语言代码，以测试单个记录中三个不同单词中的三个单独位，从而确定数据是输入文件。我对 TCP/IP 内部知之甚少，但您可能也会在那里找到位标志。

小开

我猜想在 x中还有其他位或位字段值，这是为了测试是否只设置了低阶位。在上下文中，我猜测这是默认值，因此可以跳过对这个值和一些相关的 m的编码(编码可能更昂贵) ，因为它们必须都是默认值，在构造函数或类似函数中初始化。

不管怎样，解码器必须能够推断出这些值丢失了。如果它们位于某个结构的末尾，则可以通过始终存在的 length值进行通信。

小开

操作符 ^ 是位-xor (参见 & ，|),

0 ^ 0 == 0
0 ^ 1 == 1
1 ^ 0 == 1
1 ^ 1 == 0

所以这个表达,

( x ^ 0x1 )

反转/翻转 x 的第0位(其他位保持不变)。

考虑 x 是否可以有除0x0和0x1之外的值？当 x 是单个位字段时，它只能有值0x0和0x1，但是当 x 是 int (char/short/long/etc)时，位之外的位可以影响表达式的结果。

给定的表达式允许位0旁边的位影响结果,

if ( 0 != ( x ^ 0x1 ) )

它与这个(更简单的)表达式具有同等的真实性,

if ( x ^ 0x1 )

注意，这个表达式只检查位0,

if( 0x1 & ( x ^ 0x1 ) )

所以这个表达式实际上是结合了两个表达式检查,

if( ( x & ~0x1 )  //look at all bits besides bit0
||  ( x ^ 0x1 ) ) //combine with the xor expression for bit0

作者是否打算只检查 bit0，并且打算使用这个表达式,

if( 0x1 & ( x ^ 0x1 ) )

或者，作者是否打算将 bit1-bitN 和 bit0的 xor 的值合并在一起？

小开

^ 是按位异或(XOR)操作符

如果 x = 1

          00000001   (x)       (decimal 1)
00000001   (0x1)     (decimal 1)
XOR       00000000   (0x0)     (decimal 0)

这里0 = = (x ^ 0x1)

如果 x = 0

          00000000   (x)       (decimal 0)
00000001   (0x1)     (decimal 1)
XOR       00000001   (0x1)     (decimal 0)

这里是0! = (x ^ 0x1)

X 或 b 的真值表:

a           b        a xor b
----------------------------
1           1           0
1           0           1
0           1           1
0           0           0

代码的意思就是

小开

我添加了一个新的答案，因为没有人真正解释如何直观地得到答案。

+的反数是 -。
^的反数是 ^。

如何求解 x的 0 != x - 1? + 1的两边: 0 + 1 != x - 1 + 1→ 1 != x。
如何求解 x的 0 != x ^ 1? ^ 1的两边: 0 ^ 1 != x ^ 1 ^ 1→ 1 != x。

小开

有很多好的答案，但我喜欢用一种更简单的方式来思考。

if ( 0 != ( x ^ 0x1 ) );

首先。如果参数为零，则 if 语句仅为 false。这意味着比较不等于零是没有意义的。

if ( a != 0 );
// Same as
if ( a );

所以我们只剩下:

if ( x ^ 0x1 );

一个异或和一个异或。异或所做的本质上是不同的侦查位。因此，如果所有位都相同，它将返回0。因为0是 false，所以它只有在所有位都相同的情况下才会返回 false。所以如果参数相同，则为 false，如果参数不同，则为 true，就像 不等于操作符一样。

if ( x != 0x1 );

如果事实上，两者之间的唯一区别是，!=将返回0或1，而 ^将返回任何数字，但结果的真相将始终相同。一种简单的思考方式是。

(b != c) === !!(b ^ c) // for all b and c

最后的“简化”是将 0x1转换为十进制，即1。因此，您的语句相当于:

if ( x != 1 )

小开

正如我所看到的，到目前为止的答案都忽略了一个处理 XOR的简单规则。不需要详细解释 ^和 0x的含义(以及 if和 !=等) ，表达式 0 != (x^1)可以使用以下事实进行修改:

0 != (x^1) <=> [xor left and right side by 1]
(0^1) != (x^1^1) <=>
1 != x

小开

在这里，使用 也许吧的标准技术是，为了清晰起见，重复出现在周围环境中的成语，而不是用算术上更简单但在上下文中没有意义的成语替换它，从而混淆它。

周围的代码可能会频繁地引用 (x ^ 1)，或者测试可能会问“如果位0反过来，这个位掩码是空的吗?”.

考虑到这种情况会导致某些内容被 encode()ed，可能在上下文中，位0的默认状态已经被其他因素反转了，如果有任何位偏离了它们的默认状态(通常全部为零) ，我们只需要编码额外的信息。

如果你断章取义地问这个表达是做什么的，你就忽略了它的潜在意图。您也可以查看编译器的程序集输出，看到它只是与1进行直接相等的比较。