Yo uso un byte para almacenar algunos bandera como 10101010y me gustaría saber cómo comprobar que un bit específico es en 1 o 0.

InformationsquelleAutor Pokus | 2008-09-24

10 Comentarios

  1. 46

    Aquí es una función que puede ser utilizado para probar cualquiera de bits deseada:

    bool is_bit_set(unsigned value, unsigned bitindex)
    {
        return (value & (1 << bitindex)) != 0;
    }

    Un poco de explicación:

    El operador de desplazamiento a la izquierda (<<) se utiliza para crear una máscara de bits. (1 << 0) será igual a 00000001, (1 << 1) será igual a 00000010, (1 << 3) será igual a 00001000, etc. Así que un cambio de 0 pruebas de que el último bit. Un cambio de 31 sería el de la izquierda los bits de un valor de 32 bits.

    El bit a bit-operador and (&) da un resultado donde todos los bits que son 1 en ambos lados se establecen. Ejemplos: 1111 & 0001 = 0001; 1111 & 0010 == 0010; 0000 & 0001 = 0000. Así, la expresión (valor & (1 << bitindex)) devolverá la máscara de bits si el asociado bit es 1 en valor, o 0 si el asociado bit es 0.

    Finalmente, acabamos de comprobar si el resultado es distinto de cero. (Esto podría ser dejado de lado, pero me gusta hacer explícito.)

    • Cómo sobre una aserción cuando bitindex es > 31 ?
    • Creo que la funcionalidad actual, que devolverá false en ese caso, es correcto…
    • Es este endian seguro?
    • Por qué de desplazamiento de bits no entiendo 🙁
    • Es realmente sólo un ejemplo, con la intención de demostrar cómo probar bits. En el código de producción, es posible que desee agregar algunos comprobación de errores, pero eso solo añadir ruido aquí.
    • Cambio se remota de lo que en mi ejemplo? Todos los bits a la izquierda?
    • Usted desplazamiento de bits a desplazar la 1 a la posición correcta. Si el bit índice es 3, entonces usted está cambiando 1 a la izquierda de 3, por lo que usted está revisando contra 0x000…0100
    • aceptar la bitindex se lee a partir de la 0 a la 7 de la derecha a la izquierda ! Yo tengo creo!
    • Con toda la explicación que son aceptados como respuesta. Thx.
    • Correcto. Aunque el ejemplo donde Kristopher turnos (1 << 3) debe ser 00001000 creo
    • Gracias por la captura que, mdec. Me he fijado.
    • Respecto a la pregunta de lucas: Este es endian seguro. La izquierda y la derecha operadores de desplazamiento de considerar siempre el menos significativo bit estar en el «derecho» y el más significativo en la «izquierda», sin importar el orden de los bytes.
    • También es* es un espacio de nombres reservado, aunque algunos podrían argumentar que es pedante.

  2. 6

    Como una extensión de @Daoks respuesta

    Cuando hace poco-la manipulación es realmente ayuda a tener un muy buen conocimiento de operadores bit a bit.

    También el bit a bit «Y» operador en C es &, así que lo que están queriendo hacer es:

    unsigned char a = 0xAA; //10101010 in hex
    unsigned char b = (1 << bitpos); //Where bitpos is the position you want to check
    
    if(a & b) {
        //bit set
    }
    
    else {
        //not set
    }

    Anteriormente he utilizado el bit a bit «Y» (& C) para comprobar si un bit en particular fue establecida o no. También he utilizado dos diferentes maneras de formular los números binarios. Le recomiendo que compruebe el enlace de Wikipedia arriba.

    • ¿Por qué necesito bitshift?
    • No hay ninguna razón para que usted tiene que almacenar la bitshift en una cierta variable, yo lo estaba usando como un ejemplo de un operador bit a bit. Sin embargo, si usted no bitshift usted tendrá que usar un valor explícito en algún lugar. El bitshift que usé fue una manera fácil de hacer 00000100 donde bitpos es 2 en este ejemplo
  3. 4

    Puede utilizar un operador and. Ejemplo se tiene : 10101010 y desea comprobar el tercer poco se puede hacer : (10101010 Y 00100000) y si tienes 00100000 usted sabe que usted tiene la bandera en la tercera posición a 1.

    • C no tiene un operador «and». Por otra parte, usted necesita usar un and bit a bit, no una lógica.
  4. 4

    Si usted está usando C++ y la librería estándar está permitido, te sugiero guardar sus banderas en un bitset:

    #include <bitset>
    //...
    std::bitset<8> flags(someVariable);

    entonces usted puede comprobar y establecer indicadores de uso de la [] de indexación operador.

  5. 4

    Kristopher Johnson respuesta es muy buena si te gusta trabajar con campos individuales como esta. Yo prefiero hacer el código más fácil de leer por el uso de campos de bits en C.

    Por ejemplo:

    struct fieldsample
    {
      unsigned short field1 : 1;
      unsigned short field2 : 1;
      unsigned short field3 : 1;
      unsigned short field4 : 1;
    }

    Aquí tienes una sencilla estructura con cuatro campos, cada uno de 1 bit en tamaño. Entonces usted puede escribir su código utilizando la estructura simple de acceso.

    void codesample()
    {
      //Declare the struct on the stack.
      fieldsample fields;
      //Initialize values.
      fields.f1 = 1;
      fields.f2 = 0;
      fields.f3 = 0;
      fields.f4 = 1;
      ...
      //Check the value of a field.
      if(fields.f1 == 1) {}
      ...
    }

    Obtener el mismo pequeño tamaño de la ventaja, además de un código legible debido a que usted puede dar a sus campos de nombres significativos dentro de la estructura.

    • Tenga en cuenta que un problema con el uso de campos de bits es que la forma en que están establecidos en la memoria es dependiente de la implementación, por lo que podría ser difícil de usar con los datos que intercambie con otros programas.
  6. 2

    Nadie ha estado mal hasta ahora, pero para dar un método para comprobar un poco arbitrario:

    int checkBit( byte in, int bit )
    {
      return in & ( 1 << bit );
    }

    Si la función devuelve distinto de cero, se establece el bit.

  7. 1
    byte THIRDBIT = 4; //4 = 00000100 i.e third bit is set
    
    int isThirdBitSet(byte in) {
     return in & THIRDBIT; //Returns 1 if the third bit is set, 0 otherwise
    }
  8. 1

    que usted puede hacer como Daok dice y se hace un bit a bit O a la resultante de la anterior Y de la operación. En este caso, usted va a tener un resultado final de 1 o 0.

  9. 1

    Tradicionalmente, para comprobar si el menor está establecido el bit, esto se verá algo como:

    int MY_FLAG = 0x0001;
    if ((value & MY_FLAG) == MY_FLAG)
        doSomething();
    • Que las pruebas de que un bit específico y sólo un poco está establecido.
    • No no…
    • No codificar !
  10. 0

    El uso de un bit a bit (no lógico!) y para comparar el valor con una máscara de bits.

    if (var & 0x08) {
      /* the fourth bit is set */
    }

Dejar respuesta

Please enter your comment!
Please enter your name here