Ce n' (x ^ 0 x 1) != 0 signifie?

Je suis tombé sur l'extrait de code suivant

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

Ce n' x ^ 0x1 veux dire? C'est une technique standard?

Code de la dissimulation de l' est tout à fait standard.
Il ya quelques jours j'ai aussi eu quelques situation semblable, stackoverflow.com/questions/19730348/why-101-is-11-in-c
Cela peut être résolu avec la même approche qu'un "normal" d'équation: 0 != (x ^ 1) → xor deux côtés par 1 → (0 ^ 1) != (x ^ 1 ^ 1) → simplifier → 1 != x
Je ne vois pas comment if (1 != x) est dur à écrire.
Diverses observations, d'abord par @Spook, indiquer clairement que les type de x n'est pas donné - par conséquent, nous ne savons pas c'est un entier dans cette C++ tagged problème. Bien sûr, si c'est C ou x est un entier, la réponse est facile, mais ce n'est pas une donnée et la possibilité de surcharger les operator ^ existe.
Je ne vois pas en quoi cela fait de nombreuses upvotes...

InformationsquelleAutor KodeWarrior | 2013-12-19

bit-manipulation bitmask c c++

277

De l'opération XOR (x ^ 0x1) inverse le bit 0. Donc, l'expression signifie: si le bit 0 de x est 0, ou toutes les autres bits de x est 1, alors l'expression est vraie.

L'inverse, l'expression est fausse si x == 1.

Donc, le test est le même que:
```
if (x != 1)
```
et est donc (sans doute) inutilement obscurci.
- Hey, vous ne connaissez pas le contexte. Si x est une sorte d'indicateur de bit, c'est de l'OMI, en fait, plus clair d'écrire comme c'est aujourd'hui que l'aide de l' != de l'opérateur.
- De ne pas faire. C'est un test d'égalité.
- ce n'est pas seulement un test sur un seul indicateur de bit - elle teste l'ensemble de la largeur de x. Si vous voulez juste tester un bit puis il y a de plus clair idiomes, comme l'utilisation d'un bit à bit ET.
- Je ne veux pas de vérifier si un seul indicateur est défini. Je veux vérifier si 0e drapeau est pas set et n'importe quel autre.
- Inutilement d'obfuscation? Ne savez-vous pas qu'il est de notre devoir d'obfuscation de code. Si nous avons écrit un code simple que n'importe qui pouvait comprendre, pourquoi, où irait le religieux de la sainteté de nos positions dans le monde? Nous avions soudain en commun des travailleurs comme tout le monde. L'Obfuscation est nécessaire de par la nature.
- Même alors, le test de l'ensemble de la chaîne de l'égalité est plus lisible et immédiatement compréhensible que de faire un XOR, donc c'est une mauvaise pratique d'utiliser un XOR lorsque un == le fera.
- En fait l'Épouvanteur est droit. Le test (x != 1) n'est pas équivalent. Le code peut être C++ (et en C++, ^ peut être un opérateur qui n'est rien). Si vous ne connaissez pas le contexte, @Spook est droit.
- @TheThom уєт уσυ ωяιтє ιи ¢ℓєαя тєχт
- vous devez être vécu sous une roche. Les programmeurs ont depuis longtemps devenu obsolète; depuis qu'Internet a pris le large et les ordinateurs personnels sont devenus omniprésents. Ces jours-ci, tout le monde et leur chien sont des “programmeurs” grâce à 4GLs (et misnomered 5GLs).
- Cela peut ne pas être identique à l'épreuve (x!=1), mais il devrait être.
- Cela affecterait-little/big endian systèmes différemment?
- non, il n'y a rien endian spécifiques dans le test.
- non, parce que 0x1 sera le même boutisme.
- ensuite, le code doit être supprimé le long avec le développeur responsable. Miss utilisation des opérateurs rend le code difficile à lire et à maintenir . Soit l'opérateur^ se comporte comme si les développeurs s'attendent à (XOR) ou il conduit à un comportement inattendu comme vous pouvez le voir à partir des réponses/commentaires (chacun suppose que c'est le XOR).
- il est intéressant de mentionner que l'opération XOR inverse tous les bits qui sont dans l'autre argument, ce qui se passe dans ce cas à bit 0 seulement. Il pourrait être un peu trompeur si lu hors contexte
- Non, il n'est pas. On inverse tous les bits qui sont sur les deux arguments, ou off dans les deux arguments, et les feuilles les bits d'arhat sont dans l'un et pas l'autre.
- vous avez tort. les bits qui sont à la fois argument sera éteint dans la suite, comment est-ce qu'une inversion? De toute façon, quand un argument est un masque, c'est plus naturel de regarder l'impact sur l'autre argument, qui est exactement à bascule (un.k.une inversion) les bits dans le masque.
InformationsquelleAutor Paul R
78
- ^ est le bit à bit XOR opération
- 0x1 est 1 en hexadécimal
- x ^ 0x1 inverser le dernier bit de x (reportez-vous à la XOR table de vérité dans le lien ci-dessus si ce n'est pas clair pour vous).
Donc, la condition (0 != ( x ^ 0x1 )) sera vrai si x est plus grand que 1, ou si le dernier bit de x est de 0. Ce qui ne laisse que x==1 comme une valeur à laquelle la condition sera fausse. C'est donc équivalent à
```
if (x != 1)
```
P. S. tu parles d'une façon de mettre en œuvre un tel état, je pourrais ajouter. Ne pas le faire. Et si vous devez écrire le code compliqué, laisser un commentaire. Je vous en prie.
- Ce n'est pas x==0; 4 ^ 0x1 est vrai, mais 4==0 est évidemment faux.
- "la condition semble être égal à if (x == 0)", n'est-il pas égal à x != 1?
- jamais l'esprit, j'ai fait une erreur là. Édité pour la sortir.
- L'équivalence suppose que x est un type intégral. Si c'est un float ou double, alors je crois que l'expression de rendement vrai pour 1.0 <= x < 2.0. Et si x est un type défini par l'utilisateur, l'expression pourrait retourner true si x est un Yugo, le kangourou, le célèbre compositeur de l'anniversaire, ou n'importe quel nombre qui partage au moins trois chiffres avec le courant libellé en dollar du prix du thé en Chine.
- Il n'y a pas de operator^ pour float/double.
- Vrai, mais je crois que C les valeurs de float ou double convertir implicitement à int, n'est-ce pas?
- Lorsqu'une conversion de virgule flottante entier est appelé pour, la conversion est implicite (ne nécessite pas de fonte de la syntaxe). Mais pas de conversion est déclenchée par les opérateurs au niveau du bit, ils ne parviennent tout simplement pas pour les types à virgule flottante.
- Ok, merci. Il serait toujours possible pour les types définis par l'utilisateur à la surcharge de ^ (et d'ailleurs ==) dans divers intéressant la mode.
- Vous ne pouvez pas définir de nouvelles operator fonctions pour les types fondamentaux, pour deux raisons: 1) ce n'est pas une fonction, et 2) vous ne pouvez pas créer un nouveau operator pour n'importe quel type qui est en conflit avec une définition existante de toute façon, parce que sinon, vous courez dans toutes sortes de fous "que voulez-vous dire?" au moment de la liaison.
- Je pensais que C++ types d'opérateurs ont été liés à l'opérande de gauche, donc on ne pouvait pas définir un nouveau sens pour 1^q, mais peut, par q^1. Suis-je misremembering?
- Eh bien, ça dépend sur quel type q est, de toute évidence. Vous pouvez certainement faire un MyType::operator^(float) ou similaire.
InformationsquelleAutor Violet Giraffe

Cela peut sembler simpliste comme explication, mais si quelqu'un veut aller à travers elle lentement, il est ci-dessous:

^ est un XOR au niveau du bit opérateur en c, c++ et c#.

Un XOR au niveau du bit prend deux modèles de bits de longueur égale et effectue le
logique OU exclusif sur chaque paire de bits correspondants.

OU exclusif est une opération logique qui renvoie vrai lorsque les deux
entrées différentes (l'une est vraie, l'autre est fausse).

La table de vérité de a xor b:

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

Donc, nous allons illustrer la 0 == ( x ^ 0x1 ) expression sur le niveau binaire:

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

donc:

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

InformationsquelleAutor jwaliszko

Il est OU-exclusif (XOR) de l'opérateur. Pour comprendre comment il fonctionne, vous pouvez exécuter ce code 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 sortie sera

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

De sorte que cette expression

0 != ( x ^ 0x1 )

sera égal vrai que lorsque x != 0 x 1.

Il ne change pas de x lui-même. Il vérifie seulement si x est égal à 0 ou 1. cette rxpression pourrait être changé pour

if ( x != 0x1 )

InformationsquelleAutor Vlad from Moscow

19

Il vérifie que x est en fait pas 0x1... xoring x avec 0x1 entraînera 0 seulement si x est 0x1 ... c'est un vieux truc utilisé principalement en langage d'assemblage
- Est-ce plus rapide que != 1?
- dans les temps anciens, tout en faisant de l'assemblage manuel des optimisations (x86) si je me souviens bien le xor approche contenait moins de code machine, et a été exécuté plus rapidement que l'assignation correspondante à 0... cependant, cette question contient un xor ET une comparaison, donc je pense que le != pourrait être plus rapide. Je ne suis pas si sûr cependant, il serait nécessaire de voir certains généré par le compilateur de l'assemblée.
- Pas de. Si XOR a été plus rapide que certains indigènes niveau de test d'égalité, de votre compilateur émettent des XORs pour tester l'égalité. Par conséquent, les XORs ne sont jamais plus vite que les tests d'égalité sur l'optimisation des compilateurs. Article 101 de la rédaction rapide de code est "ne pas essayer d'aider le compilateur. Vous n'aurez qu'à rendre illisible le code est plus lent dans la pratique".
- IIRC, le XOR des trucs a plus à voir avec la sauvegarde des registres de l'enregistrement d'un registre de charge b/c le littéral peut être codé directement dans le po, dans certains cas, et quelques différences subtiles avec des indicateurs d'état (mais la plupart de mes assemblée était sur 68k et DSP).
- Normalement, c'est à voir avec la compensation d'un registre (au moins sur 386+). xor eax, eax jeux eax à zéro dans les deux octets, mais mov eax, 0 prend trois ou six octets (selon le codage), et prend un peu plus de temps à décoder que le xor formulaire.
InformationsquelleAutor Ferenc Deak
18

La ^ opérateur xor au niveau du bit. Et 0x1 est le nombre 1, écrit comme une constante hexadécimale.

Donc, x ^ 0x1 donne une nouvelle valeur, qui est le même que x, mais avec le bit le moins significatif renversé.

Le code ne fait rien de plus que de comparer x avec 1, dans un très compliquées et obscures de la mode.

InformationsquelleAutor David Heffernan
11

Le xor (ou exclusif) de l'opérateur est le plus couramment utilisé pour inverser un ou plusieurs bits.
L'opération est à vous demander si exactement un des bits êtes l'un, cela soulève la table de vérité de A et de B sont des entrées, Y est de sortie):
```
A    B    Y
0    0    0
0    1    1
1    0    1
1    1    0
```
Maintenant le but de ce code semble être de vérifier si excatly le dernier bit est à 1, et les autres sont à 0, ce qui correspond if ( x != 1 ).
La raison de cet obscur méthode peut être qu'avant de manipulation de bits techniques ont été utilisées, et peut-être utilisé à d'autres endroits dans le programme.

InformationsquelleAutor Paul
8

^ est au niveau du bit xor operator dans c. Dans votre cas, x est xor ed avec 1. par exemple x a la valeur 10, puis 10d ^ 1d ===> 1010b ^ 0001b = 1011b, 1011b == 11d si la condition devient vraie.
- Faute de frappe dans votre réponse. 10 != 1010
- faute de frappe dans votre commentaire: 10 (decimal) == 1010 (binary)
- Comment est ce que quelqu'un censé savoir ce que la virgule et ce qui est binaire si vous ne mettez pas un b ou quelque chose là-bas?
- ne serait pas 0b1010 être le Pythonic façon de faire les choses?
InformationsquelleAutor Chinna
8

La bit-à-bit de test semble être une volonté délibérée de dissimulation, mais si les données sous-jacentes aux données d'entreprise à partir d'un mainframe IBM système, il peut être tout simplement que le code a été écrit afin de refléter la documentation d'origine. IBM formats de données de revenir dans les années 1960 et souvent encoder des drapeaux unique de bits dans un mot pour gagner de la place. Comme les formats ont été modifiés, les drapeaux, les octets ont été ajoutés à la fin des enregistrements existants afin d'assurer la rétrocompatibilité. La documentation d'un SMF d'enregistrement, par exemple, peut afficher le code de langage d'assemblage pour tester trois bits individuels dans un délai de trois mots différents dans un seul enregistrement de décider que les données d'un fichier d'entrée.
Je connais beaucoup moins sur TCP/IP internes, mais vous pouvez trouver des indicateurs de bits, ainsi.

InformationsquelleAutor undefined
7

L'opérateur ^ est de la bit-à-bit-xor (voir &, | ). Le résultat pour un peu, paire est,
```
0 ^ 0 == 0
0 ^ 1 == 1
1 ^ 0 == 1
1 ^ 1 == 0
```
Donc l'expression,
```
( x ^ 0x1 )
```
inverse/retourne le 0e bits de x (en laissant les autres bits inchangé).

Examiner si x peut avoir des valeurs en outre 0x0 et 0x1? Lorsque x est un seul champ de bits, il peut avoir seulement les valeurs 0 x 0 et 0 x 1, mais lorsque x est un int (char/court/long/etc), les bits d'ailleurs bit0 peut affecter le résultat de l'expression.

L'expression est donnée permet de bits à côté de bit0 à affecter le résultat,
```
if ( 0 != ( x ^ 0x1 ) )
```
Équivalente truthiness comme celui-ci (plus simple expression,
```
if ( x ^ 0x1 )
```
Remarque que cette expression serait d'examiner seulement bit0,
```
if( 0x1 & ( x ^ 0x1 ) )
```
Donc l'expression telle que présentée est vraiment la combinaison de deux expression des contrôles,
```
if( ( x & ~0x1 )  //look at all bits besides bit0
||  ( x ^ 0x1 ) ) //combine with the xor expression for bit0
```
L'auteur n'a l'intention de vérifier uniquement les bit0, et ont voulu utiliser cette expression,
```
if( 0x1 & ( x ^ 0x1 ) )
```
Ou l'auteur n'a l'intention de comingle les valeurs de bit1-bitN et le xor de bit0?

InformationsquelleAutor ChuckCottrill
7

Je suis en ajoutant un nouvel élément de réponse parce que personne n'a vraiment expliqué comment obtenir la réponse intuitive.

L'inverse de + est -.

L'inverse de ^ est ^.

Comment résoudre 0 != x - 1 pour x? Vous + 1 sur les deux côtés: 0 + 1 != x - 1 + 1 → 1 != x.

Comment voulez-vous résoudre 0 != x ^ 1 pour x? Vous ^ 1 sur les deux côtés: 0 ^ 1 != x ^ 1 ^ 1 → 1 != x.

InformationsquelleAutor Mehrdad
6

Je suppose qu'il y a d'autres éléments ou peu-les valeurs de champ dans x, et cela est destiné à tester que seul le bit est défini. Dans le contexte, je suppose que c'est la valeur par défaut, et que, par conséquent, l'encodage de ce et certains sont liés m (probablement plus cher à encoder) peuvent être ignorés, car ils doivent à la fois être la valeur par défaut, initialisé dans le constructeur ou similaire.

En quelque sorte, le décodeur doit être en mesure d'en déduire que ces valeurs sont manquantes. Si elles sont à l'extrémité de la structure, il peut être communiquée au moyen d'un length valeur qui est toujours présente.

InformationsquelleAutor Ed Staub
4

Le XOR est utile en C# drapeau enum. Pour supprimer unique indicateur de valeur d'enum, il est nécessaire d'utiliser l'opérateur xor (référence ici)

Exemple:
```
[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
```
- MAIS la question est à propos, C++, C#
- MAIS AUSSI à propos de la manipulation de bits et de masque de bits. Drapeau enum en C# est certainement au sujet de masque de bits.
- De Plus il peut être utile en C++. Voir : Pile 1 et Pile 2
- Cette réponse ne semble pas avoir quelque chose à voir avec la question d'origine, autre que la discussion de l'opérateur XOR au niveau du bit ?
InformationsquelleAutor Igrek.
4

Il y a beaucoup de bonnes réponses, mais j'aime à le dire de façon plus simple.
```
if ( 0 != ( x ^ 0x1 ) );
```
Tout d'abord. Une instruction if n'est faux si l'argument est égal à zéro. Cela signifie que la comparaison n'est pas égale à zéro est inutile.
```
if ( a != 0 );
//Same as
if ( a );
```
Alors que nous laisse avec:
```
if ( x ^ 0x1 );
```
Un XOR avec une. Ce qu'un XOR n'est essentiellement détecter bits qui sont différents. Ainsi, si tous les bits sont les mêmes, il sera de retour 0. Puisque 0 est faux, la seule fois où il retournera false si tous les bits sont les mêmes. Ainsi, il sera faux si les arguments sont les mêmes, même s'ils sont différents...tout comme les pas égal à opérateur.
```
if ( x != 0x1 );
```
Si fait, la seule différence entre les deux est que != renvoie 0 ou 1, alors que ^ sera de retour n'importe quel nombre, mais la truthyness le résultat sera toujours le même. Un moyen facile de le penser il est.
```
(b != c) === !!(b ^ c) //for all b and c
```
La finale de la "simplification" est la conversion de 0x1 à la décimale qui est de 1. Par conséquent, votre déclaration est équivalent à:
```
if ( x != 1 )
```
InformationsquelleAutor Kevin Cox

^ est un XOR au niveau du bit opérateur

Si x = 1

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

ici 0 == ( x ^ 0 x 1 )

Si x = 0

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

ici 0 != ( x ^ 0 x 1 )

La table de vérité du xor b:

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

Le code signifie simplement

Est-il vraiment nécessaire de poster encore un autre double réponse?
vous pouvez dire qu'une autre réponse, mais pas en double. désolé si vous avez l'esprit

InformationsquelleAutor akbar ali

1

La norme technique qui pourrait être utilisé, ici, est de répéter un langage tel qu'il apparaît dans le contexte environnant, pour plus de clarté, plutôt que de les dissimuler en la remplaçant par un idiome qui est arithmétiquement plus simple mais contextuellement pas de sens.

Le code environnant peut faire référence fréquente à (x ^ 1), ou le test peut se demander "si le bit 0 est dans l'autre sens, ne serait-ce masque de bits est vide?".

Étant donné que la condition qui provoque quelque chose à encode()ed, peut-être que dans le contexte de l'état par défaut du bit 0 a été inversé par d'autres facteurs, et nous avons seulement besoin de coder des informations supplémentaires si l'un des bits de dévier de leur valeur par défaut (normalement tous les zéro).

Si vous prenez l'expression de leur contexte et de demander ce qu'il fait, vous donnent l'intention sous-jacente. On pourrait tout aussi bien regarder l'assemblée de sortie du compilateur et de voir qu'il est tout simplement un direct comparaison d'égalité avec 1.

InformationsquelleAutor sh1
0

Que je vois les réponses manquer une règle simple pour la manipulation de XORs. Sans entrer dans les détails de ce ^ et 0x moyenne (et if, et != etc), l'expression 0 != (x^1) peut être remaniée comme suit en utilisant le fait que (a^a)==0:
```
0 != (x^1) <=> [xor left and right side by 1]
(0^1) != (x^1^1) <=>
1 != x
```
InformationsquelleAutor Serge Rogatch

Vous devez vous connecter pour publier un commentaire.