Come ottengo i dati bit per bit da un valore intero in C?

Question

Voglio estrarre i bit di un numero decimale.

Ad esempio, 7 è binario 0111 e voglio ottenere 0 1 1 1 tutti i bit memorizzati in bool. Come posso farlo?

OK, un ciclo non è una buona opzione, posso fare qualcos'altro per questo?

Answer 1

Se si desidera che il bit k-esimo di n, poi fare

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

Qui creiamo una maschera, applicare la maschera per n, e poi a destra spostare il valore mascherato per ottenere solo il bit che vogliamo . Potremmo scrivere di più pienamente come:

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

Si può leggere di più su bit-mascheramento here.

Ecco un programma:

#include <stdio.h> 
#include <stdlib.h> 

int *get_bits(int n, int bitswanted){ 
    int *bits = malloc(sizeof(int) * bitswanted); 

    int k; 
    for(k=0; k<bitswanted; k++){ 
    int mask = 1 << k; 
    int masked_n = n & mask; 
    int thebit = masked_n >> 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"); 
} 

Answer 2

Ecco un modo per farlo, ci sono molti altri:

bool b[4]; 
int v = 7; // number to dissect 

for (int j = 0; j < 4; ++j) 
    b [j] = 0 != (v & (1 << j)); 

Answer 3

Ecco un modo molto semplice per farlo;

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

Answer 4

#include <stdio.h> 

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<<i < 0; 
      printf("%d", vbool[i]); 
     } 
    return 0; 
} 

Answer 5

Se non si desidera alcun loop, dovrete scriverlo:

#include <stdio.h> 
#include <stdbool.h> 

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; 
} 

Come dimostrato qui, questo funziona anche in un inizializzatore.

Answer 6

Come richiesto, ho deciso di estendere il mio commento sulla risposta dell'indice a una risposta a tutti gli effetti. Sebbene la sua risposta sia corretta, è inutilmente complessa. Inoltre tutte le risposte correnti utilizzano lo int s firmato per rappresentare i valori. Ciò è pericoloso, poiché lo spostamento verso destra dei valori negativi è definito dall'implementazione (ossia non è trasferibile) e lo spostamento a sinistra può portare a comportamenti non definiti (vedere this question).

Spostando a destra il bit desiderato nella posizione di bit meno significativa, il mascheramento può essere eseguito con 1. Non è necessario calcolare un nuovo valore di maschera per ogni bit.

(n >> k) & 1 

Come un programma completo, l'informatica (e successivamente la stampa) una matrice di valori bit singoli:

#include <stdio.h> 
#include <stdlib.h> 

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); 
} 

Supponendo che si desidera calcolare tutti i bit come in questo caso, e non uno specifico , il ciclo può essere ulteriormente modificata per

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

Questa modifica input in posizione e quindi permette l'uso di una larghezza costante, spostamento singolo bit, che può essere più efficace su alcuni un rchitectures.

Answer 7

@prateek grazie per il vostro aiuto. Ho riscritto la funzione con i commenti per l'uso in un programma. Aumentare 8 per più bit (fino a 32 per un intero).

std::vector <bool> bits_from_int (int integer) // discern which bits of PLC codes are true 
{ 
    std::vector <bool> 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; 
} 

Answer 8

Uso std::bitset

int value = 123; 
std::bitset<sizeof(int)> bits(value); 
std::cout <<bits.to_string();