Comment est l'état de travail avec des opérateurs bit par bit?

J'ai essayé de comprendre comment, si la condition de travailler avec les opérateurs au niveau du bit.
Une façon de vérifier si un nombre est pair ou impair peut être fait par:

#include <iostream>
#include <string>
using namespace std;

string test()
{
    int i = 8;  //a number
    if(i & 1)
      return "odd";

    else
      return "even";       
}

int main ()
{
  cout << test();
  return 0;
}

La Partie que je ne comprends pas, c'est comment la si la condition de travail. Dans ce cas, si i = 8 alors la dans Si l'état il est en train de faire 1000 & 1 qui devrait redonne 1000 qui égale 8.

Si i = 7, puis dans si l'état qu'elle doit faire 111 & 1 qui donne en retour, 111, ce qui égale 7

Pourquoi est-ce le cas que si(8) sera de retour "même" et si(7) le retour de "bizarre"? Je suppose que je veux comprendre ce que l'instruction if vérifie pour être Vrai et du Faux lorsque vous traitez avec des opérateurs bit par bit.

Juste Une pensée quand j'ai écrit cette question est en bas, parce que c'est en train de faire 

for 8: 1000 & 0001 which gives 0
for 7: 0111 & 0001 which gives 1?
  • Votre présomptions sur ce x & y retour sont mauvais.
  • "ce que l'instruction if vérifie pour être Vrai et du Faux lorsque vous traitez avec des opérateurs bit par bit." - condition de la vérification juste se soucie le résultat final, mais jamais à la façon dont il est calculé.
  • & est au niveau du bit. 1000 est 1111101000, tandis que 1 est 1. 1111101000 & 1 est 0, donc c'est faux.
  • Je vous assure, sur les pas de système est décimal 8 représentée comme 1111101000. Sur presque tous les systèmes, il est 00001000.
  • Je reçois la nette impression que vous êtes à la traîne. Ce n'est pas la première fois que vous avez répondu à un commentaire de la mine dans un tout façon absurde.
  • Votre premier commentaire n'a aucun sens. Pourriez-vous la reformuler?
  • Il est probable que le nombre de mille (1000 en décimal) est 1111101000 en binaire.
  • Je ne vois pas comment le nombre mille est pertinente ici, car les exemples d'utilisation de sept et huit.

InformationsquelleAutor user1655072 | 2012-10-24
  1. 16

    Oui, vous avez raison dans la dernière partie. Binaire & et | sont effectuées, bit par bit. Depuis

    1 & 1 == 1
1 & 0 == 0
0 & 1 == 0
0 & 0 == 0

    nous pouvons voir que:

    8 & 1 == 1000 & 0001 == 0000

    et 

    7 & 1 == 0111 & 0001 == 0001

    Votre test fonction correctement calculer si un nombre est pair ou impair, parce que a & 1 teste si il y a un 1 dans le 1s endroit, qui n'est seulement pour les nombres impairs.

    • rien de plus à dire ici 🙂 Peut-être ajouter que 1 & 0 = 0, 1 & 1 = 1 et 0 & 1 = 0
    InformationsquelleAutor Xymostech
  2. 4

    En fait, en C, C++ et d'autres grands langages de programmation les & opérateur ne AND opérations dans chacun des bits pour les types intégraux. Le n-ième bit en bit à bit AND est égal à 1 si et seulement si le n-ième bit de deux opérandes sont égaux à 1.

    Par exemple:

    8 & 1 =
1000 - 8
0001 - 1
----
0000 - 0

7 & 1 =
0111 - 7
0001 - 1
----
0001 - 1

7 & 5 =
0111 - 7
0101 - 5
----
0101 - 5

    Pour cette raison, faire un bit à bit AND entre un nombre pair et 1 sera toujours égale 0 car seuls les nombres impairs ont leur bit le moins significatif égal à 1.

    InformationsquelleAutor Murilo Vasconcelos
  3. 3

    if(x) en C++ convertit x booléens. Un entier est considéré comme true ssi il est différent de zéro.

    Ainsi, tous les if(i & 1) est en train de faire est de vérifier pour voir si les moins significatif bit est défini dans i. Si elle est définie, i&1 sera différente de zéro; si elle n'est pas définie, i&1 sera de zéro.

    Le bit le moins significatif est situé dans un entier iff cet entier est impair, donc i&1 est différente de zéro iff i est impair.

    • C'est le C++ si. true est vrai et false est faux, juste que les entiers et les pointeurs sont toujours implicitement convertible bool.
    • oui, oui, j'ai un peu raté. fixe.
    InformationsquelleAutor nneonneo
  4. 2

    L'expression i & 1, où i est un int, a type int. Sa valeur est 1 ou 0, selon la valeur de la faible peu de i. Dans la déclaration if(i & 1), le résultat de cette expression est convertie bool, suivant la règle habituelle pour les types d'entiers: 0 devient false et non-zéro devient true.

    InformationsquelleAutor Pete Becker
  5. 2

    Ce que vous dites, le code est fait est fait comment bit à bit les opérateurs sont censés travailler. Dans votre exemple de (8 & 1):

    1000 & 0001 = 0000

    parce que dans la première valeur, le dernier bit est mis à 0, tandis que dans la deuxième valeur, le dernier bit est mis à 1. 0 & 1 = 0.

    0111 & 0001 = 0001

    Dans ces deux valeurs, le dernier bit est mis à 1, de sorte que le résultat est 1, puisque 1 & 1 = 1.

    InformationsquelleAutor Darius Makaitis