¿Qué significa (x ^ 0x1)! = 0?

Me encontré con el siguiente fragmento de código

if( 0 != ( x ^ 0x1 ) )
     encode( x, m );

Que x ^ 0x1significa ¿Es esta una técnica estándar?

La operación XOR ( x ^ 0x1) invierte el bit 0. Por lo tanto, la expresión significa efectivamente: si el bit 0 de x es 0, o cualquier otro bit de x es 1, entonces la expresión es verdadera.

Por el contrario, la expresión es falsa si x == 1.

Entonces la prueba es la misma que:

if (x != 1)

y por lo tanto (posiblemente) se ofusca innecesariamente.

• ^es la operación XOR bit a bit
• 0x1está 1en notación hexadecimal
• x ^ 0x1invertirá el último bit de x(consulte la tabla de verdad XOR en el enlace de arriba si no está claro para usted).

Entonces, la condición (0 != ( x ^ 0x1 ))será verdadera si xes mayor que 1 o si el último bit de xes 0. Lo que solo deja x == 1 como un valor en el que la condición será falsa. Entonces es equivalente a

if (x != 1)

PD: Una manera increíble de implementar una condición tan simple, podría agregar. No hagas eso. Y si debe escribir un código complicado, deje un comentario . Te lo ruego.

Esto puede parecer una explicación demasiado simplificada, pero si a alguien le gustaría hacerlo lentamente, está debajo:

^es un operador XOR bit a bit en c, c ++ y c #.

Un XOR bit a bit toma patrones de dos bits de igual longitud y realiza la operación OR exclusiva lógica en cada par de bits correspondientes.

OR exclusivo es una operación lógica que genera verdadero siempre que ambas entradas difieran (una es verdadera, la otra es falsa).

La tabla de verdad de a xor b :

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

Así que vamos a ilustrar la 0 == ( x ^ 0x1 )expresión a nivel binario:

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

entonces:

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

Es operador exclusivo OR (XOR). Para entender cómo funciona, puede ejecutar este código simple

    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;

La salida será

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

Entonces esta expresión

0 != ( x ^ 0x1 )

será igual de verdadero solo cuando x! = 0x1.

No cambia x sí mismo. Solo comprueba si x es igual a 0 o 1. esta rxpression podría cambiarse a

if ( x != 0x1 )

Se comprueba que xen realidad no es 0x1... xorING xcon 0x1resultará en 0 sólo si xes 0x1... esto es un viejo truco utilizado sobre todo en lenguaje ensamblador

El ^operador es bit a bit xor. Y 0x1es el número 1, escrito como una constante hexadecimal.

Por lo tanto, se x ^ 0x1evalúa a un nuevo valor que es el mismo que x, pero con el bit menos significativo invertido.

El código no hace nada más que comparar x con 1, de una manera muy complicada y oscura.

El operador xor (exclusivo o) se usa más comúnmente para invertir uno o más bits. La operación es preguntar si exactamente uno de los bits es uno, esto lleva a la siguiente tabla de verdad (A y B son entradas, Y es salida):

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

Ahora, el propósito de este código parece ser verificar si excatly el último bit es 1, y los otros son 0, esto es igual if ( x != 1 ). La razón de este método oscuro podría ser que se han utilizado técnicas de manipulación de bits anteriores y tal vez se utilizan en otros lugares del programa.

^es bit xor operatora bit adentro c. En su caso, x es xor'ed con 1. por ejemplo xtiene el valor 10, entonces la 10d ^ 1d ===> 1010b ^ 0001b = 1011b, 1011b == 11dcondición se vuelve verdadera.

La prueba bit a bit parece ser una ofuscación deliberada, pero si los datos subyacentes son datos corporativos de un sistema mainframe de IBM, puede ser simplemente que el código se escribió para reflejar la documentación original. Los formatos de datos de IBM se remontan a la década de 1960 y con frecuencia codifican banderas como bits individuales dentro de una palabra para ahorrar almacenamiento. A medida que se modificaron los formatos, se agregaron bytes de marca al final de los registros existentes para mantener la compatibilidad con versiones anteriores. La documentación para un registro SMF, por ejemplo, podría mostrar el código del lenguaje ensamblador para probar tres bits individuales dentro de tres palabras diferentes en un solo registro para decidir que los datos eran un archivo de entrada. Sé mucho menos sobre los componentes internos de TCP / IP, pero también puede encontrar indicadores de bits allí.

El operador ^ es bitwise-xor (ver &, |). El resultado para un par de bits es,

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

Entonces la expresión,

( x ^ 0x1 )

invierte / voltea el bit 0 de x (dejando otros bits sin cambios).

Considere si x puede tener valores además de 0x0 y 0x1? Cuando x es un campo de un solo bit, solo puede tener valores 0x0 y 0x1, pero cuando x es un int (char / short / long / etc), los bits además de bit0 pueden afectar el resultado de la expresión.

La expresión dada permite que los bits al lado de bit0 afecten el resultado,

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

Que tiene una veracidad equivalente a esta expresión (más simple),

if ( x ^ 0x1 )

Tenga en cuenta que esta expresión examinaría solo bit0,

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

Entonces, la expresión presentada realmente combina dos verificaciones de expresión,

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

¿El autor tenía la intención de verificar solo bit0, y tenía la intención de usar esta expresión,

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

¿O el autor tenía la intención de combinar los valores para bit1-bitN y el xor de bit0?

Estoy agregando una nueva respuesta porque nadie realmente explicó cómo obtener la respuesta intuitivamente.

El inverso de +es -.
El inverso de ^es ^.

¿Cómo resolver 0 != x - 1para x? Usted + 1a ambos lados: 0 + 1 != x - 1 + 1→ 1 != x.
¿Cómo resolver 0 != x ^ 1para x? Usted ^ 1a ambos lados: 0 ^ 1 != x ^ 1 ^ 1→ 1 != x.

Supongo que hay otros bits o valores de campo de bits x, y esto está destinado a probar que solo se establece el bit de orden inferior. En el contexto, supongo que este es el valor predeterminado y, por lo tanto, la codificación de esto y algunos relacionadosm , por lo tanto, se puede omitir la (probablemente más caros de codificar), porque ambos deben ser el valor predeterminado, inicializados en un constructor o similar.

De alguna manera, el decodificador debe poder inferir que faltan estos valores. Si están al final de alguna estructura, puede comunicarse a través de un lengthvalor que siempre está presente.

El XOR es útil en la enumeración de bandera de C #. Para eliminar un solo indicador del valor de enumeración, es necesario utilizar el operador xor (consulte aquí )

Ejemplo:

[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

Hay muchas buenas respuestas, pero me gusta pensar de una manera más simple.

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

Ante todo. Una declaración if solo es falsa si el argumento es cero. Esto significa que comparar no igual a cero no tiene sentido.

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

Entonces eso nos deja con:

if ( x ^ 0x1 );

Un XOR con uno. Lo que hace un XOR es esencialmente detectar bits que son diferentes. Entonces, si todos los bits son iguales, devolverá 0. Dado que 0 es falso, la única vez que devolverá falso es si todos los bits son iguales. Por lo tanto, será falso si los argumentos son los mismos, verdadero si son diferentes ... al igual que el operador no igual a .

if ( x != 0x1 );

De hecho, la única diferencia entre los dos es que !=devolverá 0 o 1, mientras ^que devolverá cualquier número, pero la veracidad del resultado siempre será la misma. Una manera fácil de pensarlo es.

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

La "simplificación" final es convertir 0x1a decimal, que es 1. Por lo tanto, su declaración es equivalente a:

if ( x != 1 )

^ es un operador XOR bit a bit

Si x = 1

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

aquí 0 == (x ^ 0x1)

Si x = 0

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

aquí 0! = (x ^ 0x1)

La tabla de verdad de a xor b:

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

El código simplemente significa

La técnica estándar que podría estar siendo utilizada, aquí, es repetir un modismo tal como aparece en el contexto circundante para mayor claridad, en lugar de ofuscarlo reemplazándolo por un modismo que es aritméticamente más simple pero contextualmente sin sentido.

El código circundante puede hacer referencia frecuente a (x ^ 1) , o la prueba puede estar preguntando "si el bit 0 fuera al revés, ¿esta máscara de bits estaría vacía?".

Dado que la condición hace que algo sea encode() edite , puede ser que, en contexto, el estado predeterminado del bit 0 haya sido invertido por otros factores, y solo necesitamos codificar información adicional si alguno de los bits se desvía de su valor predeterminado (normalmente todo cero )

Si toma la expresión fuera de contexto y pregunta qué hace, pasa por alto la intención subyacente. También podría mirar la salida del ensamblaje del compilador y ver que simplemente hace una comparación de igualdad directa con 1.

Como veo, las respuestas hasta ahora pierden una regla simple para manejar XORs. Sin entrar en detalles sobre qué ^y qué 0xsignifican (y if, y !=etc.), la expresión 0 != (x^1)se puede reelaborar de la siguiente manera utilizando el hecho de que (a^a)==0:

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