Trouver des positions de bits dans un entier 32 bits non signé

Question

Je pense que je me suis peut-être endormi dans ma classe CS quand ils ont parlé de Bit Positions, donc j'espère que quelqu'un peut donner un coup de main.

J'ai un entier de 32 bits non signé (la valeur permet d'utiliser: 28)

Selon certains documents, je vais plus, la valeur de l'entier contient des drapeaux spécifiant diverses choses.

Les positions des bits dans le drapeau sont numérotées de 1 (ordre inférieur) à 32 (ordre supérieur). Tous les bits de fanion non définis sont réservés et doivent être mis à 0.

J'ai un tableau qui montre les significations des fanions, avec une signification pour les numéros 1-10. J'espère que quelqu'un peut essayer de m'expliquer ce que tout cela signifie et comment trouver la valeur "flag" d'un nombre comme, 28, basé sur la position du bit.

Merci

Answer 1

2 8 convertit en 11100 en binaire. Cela signifie que les bits 1 et 2 ne sont pas définis et que les bits 3, 4 et 5 sont définis.

Quelques points: tout d'abord, tout le monde qui est vraiment habitué à C commence généralement la numérotation à 0, pas 1. En second lieu, vous pouvez tester des drapeaux individuels avec l'opérateur de bits et l'opérateur (&), comme dans:

#define flag1 1 // 1 = 00 0001 
#define flag2 2 // 2 = 00 0010 
#define flag3 4 // 4 = 00 0100 
#define flag4 8 // 8 = 00 1000 
#define flag5 16 // 16 = 01 0000 
#define flag6 32 // 32 = 10 0000 

if (myvalue & flag1) 
    // flag1 was set 

if (myvalue & flag4) 
    // flag4 was set 

et ainsi de suite. Vous pouvez également vérifier quels bits sont dans une boucle:

#include <stdio.h> 

int main() { 
    int myvalue = 28; 
    int i, iter; 

    for (i=1, iter=1; i<256; i<<=1, iter++) 
     if (myvalue & i) 
      printf("Flag: %d set\n", iter); 
    return 0; 
} 

devrait imprimer:

Flag: 3 set 
Flag: 4 set 
Flag: 5 set 

Answer 2

Si l'on suppose flags est non signé ...

int flag_num = 1; 
while (flags != 0) 
{ 
    if ((flags&1) != 0) 
    { 
     printf("Flag %d set\n", flags); 
    } 
    flags >>= 1; 
    flag_num += 1; 
} 

Si vous flags est signé doit remplacer

flags >>= 1; 

avec

flags = (flags >> 1) & 0x7fffffff; 

Answer 3

Pour obtenir un int avec la valeur 0 ou 1 représentant seulement le n bit e de cet entier, l'utilisation :

int bitN = (value >> n) & 1; 

Mais ce n'est généralement pas ce que vous voulez faire. Un idiome plus commun est le suivant:

int bitN = value & (1 << n); 

Dans ce cas bitN sera 0 si le bit n e est pas défini et non nul dans le cas où le bit n e est réglé. (Plus précisément, ce sera n'importe quelle valeur sort avec seulement le bit n.)

Answer 4

lieu de boucle à travers chaque bit, vous pouvez faire une boucle à la place à travers seulement les bits de réglage, ce qui peut être plus rapide si vous vous attendez bits à mettre à faible densité:

Assumer le champ de bits est (entier scalaire) champ variable.

while (field){ 
    temp = field & -field; //extract least significant bit on a 2s complement machine 
    field ^= temp; // toggle the bit off 
    //now you could have a switch statement or bunch of conditionals to test temp 
    //or get the index of the bit and index into a jump table, etc. 
} 

fonctionne assez bien lorsque le champ de bits ne se limite pas à la taille d'un seul type de données, mais il pourrait être d'une certaine taille arbitraire. Dans ce cas, vous pouvez extraire 32 bits (ou n'importe quelle taille de votre registre) à la fois, le tester par rapport à 0, puis passer au mot suivant.

Answer 5

Utilisez une fonction de journal, avec la base 2. En python, qui ressemblerait à ceci:

import math 

position = math.log(value, 2) 

Si la position n'est pas un entier, plus de 1 bit a été fixé à 1.

Answer 6

A légère variation de réponse-

unsigned int tmp_bitmap = x;   
while (tmp_bitmap > 0) { 
    int next_psn = __builtin_ffs(tmp_bitmap) - 1; 
    tmp_bitmap &= (tmp_bitmap-1); 
    printf("Flag: %d set\n", next_psn); 
} 

Answer 7

// You can check the bit set positions of 32 bit integer. 
// That's why the check is added "i != 0 && i <= val" to iterate till 
// the end bit position. 
    void find_bit_pos(unsigned int val) { 
      unsigned int i; 
      int bit_pos; 
      printf("%u::\n", val); 
      for(i = 1, bit_pos = 1; i != 0 && i <= val; i <<= 1, bit_pos++) { 
        if(val & i) 
          printf("set bit pos: %d\n", bit_pos); 
      } 
    }