Considere una variable unsigned int a; Cía.
Ahora diga que quiero establecer cualquier i’th bit en esta variable a ‘1’.
Tenga en cuenta que la variable tiene algún valor. Entonces a=(1<<i) no funcionará.
a=a+(1<<i) funcionará, pero estoy buscando la forma más rápida. ¿¿Cualquier cosa??
Bitwise o eso. por ejemplo, a |= (1<
Algunas macros de manipulación de bits útiles.
#define BIT_MASK(bit) (1 << (bit)) #define SET_BIT(value,bit) ((value) |= BIT_MASK(bit)) #define CLEAR_BIT(value,bit) ((value) &= ~BIT_MASK(bit)) #define TEST_BIT(value,bit) (((value) & BIT_MASK(bit)) ? 1 : 0)
La forma más común de hacer esto es:
a |= (1 << i);
Esto es sólo dos operaciones: un turno y un OR. Es difícil ver cómo se puede mejorar esto.
Debes usar bitwise O para esta operación.
a |= 1 << i;
Probablemente podrías usar
a |= (1 << i)
Pero no hará mucha diferencia. En cuanto al rendimiento, no deberías ver ninguna diferencia.
Podría intentar construir una tabla donde 0x0010 i a una máscara de bits (como 2 => 0x0010 para 0000000000100 ), pero eso es un poco innecesario.
Podrías usar un bit a bit o
a |= (1 << i);
Tenga en cuenta que esto no tiene el mismo comportamiento que +, que se cargará si ya hay un 1 en el bit que está configurando.
La forma en que implementé las marcas de bits (para citar directamente de mi base de código, puede usarlo libremente para cualquier propósito, incluso comercial):
void SetEnableFlags(int &BitFlags, const int Flags) { BitFlags = (BitFlags|Flags); } const int EnableFlags(const int BitFlags, const int Flags) { return (BitFlags|Flags); } void SetDisableFlags(int BitFlags, const int Flags) { BitFlags = (BitFlags&(~Flags)); } const int DisableFlags(const int BitFlags, const int Flags) { return (BitFlags&(~Flags)); }
No se necesita operación de cambio a nivel de bits.
Es posible que tenga que ordenar o alterar el código para usar el conjunto de variables en particular que está usando, pero en general debería funcionar bien.