Comment puis-je obtenir des données bit à bit à partir d’une valeur entière en C?

Je veux extraire des bits d’un nombre décimal.

Par exemple, 7 est le binary 0111, et je veux obtenir 0 1 1 1 tous les bits stockés dans bool. Comment puis-je le faire?

OK, une boucle n’est pas une bonne option, puis-je faire autre chose?

Si vous voulez le k-ème bit de n, alors faites

(n & ( 1 << k )) >> k 

Ici, nous créons un masque, appliquons le masque à n, puis décalons à droite la valeur masquée pour obtenir juste le bit que nous voulons. Nous pourrions l’écrire plus complètement comme:

  int mask = 1 << k; int masked_n = n & mask; int thebit = masked_n >> k; 

Vous pouvez en savoir plus sur le masquage de bits ici .

Voici un programme:

 #include  #include  int *get_bits(int n, int bitswanted){ int *bits = malloc(sizeof(int) * bitswanted); int k; for(k=0; k> k; bits[k] = thebit; } return bits; } int main(){ int n=7; int bitswanted = 5; int *bits = get_bits(n, bitswanted); printf("%d = ", n); int i; for(i=bitswanted-1; i>=0;i--){ printf("%d ", bits[i]); } printf("\n"); } 

Comme demandé, j’ai décidé d’étendre mon commentaire sur la réponse de l’index à une réponse complète. Bien que sa réponse soit correcte, elle est inutilement complexe. De plus, toutes les réponses actuelles utilisent des int signés pour représenter les valeurs. Ceci est dangereux, car le déplacement à droite des valeurs négatives est défini par la mise en œuvre (c’est-à-dire non portable) et le décalage vers la gauche peut conduire à un comportement indéfini (voir cette question ).

En déplaçant à droite le bit souhaité dans la position de bit la moins significative, le masquage peut être effectué avec 1 . Pas besoin de calculer une nouvelle valeur de masque pour chaque bit.

 (n >> k) & 1 

En tant que programme complet, calcul (et impression ultérieure) d’un tableau de valeurs à un seul bit:

 #include  #include  int main(int argc, char** argv) { unsigned input = 0b0111u, n_bits = 4u, *bits = (unsigned*)malloc(sizeof(unsigned) * n_bits), bit = 0; for(bit = 0; bit < n_bits; ++bit) bits[bit] = (input >> bit) & 1; for(bit = n_bits; bit--;) printf("%u", bits[bit]); printf("\n"); free(bits); } 

En supposant que vous voulez calculer tous les bits, comme dans ce cas, et non dans un cas particulier, la boucle peut être modifiée en

 for(bit = 0; bit < n_bits; ++bit, input >>= 1) bits[bit] = input & 1; 

Cela modifie l’ input en place et permet ainsi l’utilisation d’un décalage d’un bit à largeur constante, qui peut être plus efficace sur certaines architectures.

Voici une façon de le faire – il y en a beaucoup d’autres:

 bool b[4]; int v = 7; // number to dissect for (int j = 0; j < 4; ++j) b [j] = 0 != (v & (1 << j)); 

Voici un moyen très simple de le faire;

 int main() { int s=7,l=1; vector  v; v.clear(); while (l <= 4) { v.push_back(s%2); s /= 2; l++; } for (l=(v.size()-1); l >= 0; l--) { cout< 

@prateek merci pour votre aide. J’ai réécrit la fonction avec des commentaires pour une utilisation dans un programme. Augmentez 8 pour plus de bits (jusqu’à 32 pour un entier).

 std::vector  bits_from_int (int integer) // discern which bits of PLC codes are true { std::vector  bool_bits; // continously divide the integer by 2, if there is no remainder, the bit is 1, else it's 0 for (int i = 0; i < 8; i++) { bool_bits.push_back (integer%2); // remainder of dividing by 2 integer /= 2; // integer equals itself divided by 2 } return bool_bits; } 

Si vous ne voulez pas de boucles, vous devrez les écrire:

 #include  #include  int main(void) { int num = 7; #if 0 bool arr[4] = { (num&1) ?true: false, (num&2) ?true: false, (num&4) ?true: false, (num&8) ?true: false }; #else #define BTB(v,i) ((v) & (1u << (i))) ? true : false bool arr[4] = { BTB(num,0), BTB(num,1), BTB(num,2), BTB(num,3)}; #undef BTB #endif printf("%d %d %d %d\n", arr[3], arr[2], arr[1], arr[0]); return 0; } 

Comme démontré ici, cela fonctionne également dans un initialiseur.

Utiliser std::bitset

 int value = 123; std::bitset bits(value); std::cout < 
 #include  int main(void) { int number = 7; /* signed */ int vbool[8 * sizeof(int)]; int i; for (i = 0; i < 8 * sizeof(int); i++) { vbool[i] = number<