¿Cómo obtengo datos bit a bit a partir de un valor entero en C?

Question

Quiero extraer bits de un número decimal.

Por ejemplo, 7 es 0111 binario, y quiero obtener 0 1 1 1 todos los bits almacenados en bool. ¿Como lo puedo hacer?

OK, un bucle no es una buena opción, ¿puedo hacer algo más por esto?

Answer 1

Si desea que el bit de orden k de n, y luego hacer

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

Aquí creamos una máscara, aplicar la máscara a n, y luego desplazamiento a la derecha del valor enmascarado para obtener sólo el bit queremos . Podríamos escribirlo más plenamente como:

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

Puede leer más sobre bits de enmascaramiento here.

Aquí es un programa:

#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

Ésta es una forma de hacerlo, hay muchos otros:

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

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

Answer 3

Aquí está una manera muy simple de hacerlo;

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

Si no desea ningún bucle, que tendrá que escribirlo:

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

Como se ha demostrado aquí, esto también funciona en un inicializador.

Answer 6

Según lo solicitado, decidí extender mi comentario en la respuesta del índice a una respuesta en toda regla. Aunque su respuesta es correcta, es innecesariamente compleja. Además, todas las respuestas actuales utilizan int s firmado para representar los valores. Esto es peligroso, ya que el desplazamiento a la derecha de los valores negativos está definido por la implementación (es decir, no es portátil) y el desplazamiento a la izquierda puede conducir a un comportamiento indefinido (ver this question).

Al desplazar a la derecha la broca deseada a la posición de bit menos significativa, se puede enmascarar con 1. No es necesario calcular un nuevo valor de máscara para cada bit.

(n >> k) & 1 

Como un programa completo, la informática (y posteriormente imprimir) una matriz de valores de un solo bit:

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

Suponiendo que se desea calcular todos los bits como en este caso, y no una específica , el bucle se puede cambiar más a

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

Esto modifica input en su lugar y de esta manera permite el uso de una anchura constante, el cambio de un solo bit, que puede ser más eficiente en algunos una arquitecturas.

Answer 7

@prateek gracias por su ayuda. Reescribí la función con comentarios para usar en un programa. Aumenta 8 para más bits (hasta 32 para un entero).

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

Usando std::bitset

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