¿Cómo se configura, borra y cambia un bit?

¿Cómo configura, borra y cambia bits en C / C ++?

2210
07 сент. fijado por jeffv 07 sept. 2008-09-07 03:42 '08 a las 3:42 2008-09-07 03:42
@ 27 respuestas

Ajuste de bits

Utilice el operador OR a nivel de bits ( | ) para establecer el bit.

 number |= 1UL << n; 

Esto establecerá el n bit del number . n debe ser cero si desea establecer el primer bit y así sucesivamente a n-1 si desea establecer el n bit.

Use 1ULL si el number mayor que el unsigned long ; la promoción 1UL << n produce solo después de la evaluación 1UL << n donde el comportamiento indefinido cambia más que el ancho. Lo mismo se aplica a todos los otros ejemplos.

Brocas de limpieza

Use el operador AND a bit ( > ) para borrar el bit.

 number  ~(1UL << n); 

Esto borrará el n bit del number . Debe invertir la cadena de bits con el operador NOT ( ~ ) a nivel de bits, y luego Y.

Cambiar un poco

El operador XOR ( ^ ) se puede utilizar para cambiar bits.

 number ^= 1UL << n; 

Esto cambiará el n bit del number .

Comprobar bit

No lo pediste, pero también podría agregarlo.

Para verificar un bit, mueva el número n a la derecha, luego a bit a bit. Y esto:

 bit = (number >> n)  1U; 

Esto pondrá el valor del n bit del number en una variable de bit .

Cambiar nth bit a x

La configuración del n bit en 1 o 0 se puede lograr usando la siguiente implementación de las 2 adiciones de C ++:

 number ^= (-x ^ number)  (1UL << n); 

El bit n se establecerá si x es 1 , y se borrará si x es 0 . Si x tiene un significado diferente, obtienes basura. x = !!x lo boolean a 0 o 1.

Para hacerlo independiente del comportamiento de los complementos complementarios 2 (donde -1 tiene todos los bits establecidos, en lugar de implementar un complemento o signo / valor C ++), use la negación sin signo.

 number ^= (-(unsigned long)x ^ number)  (1UL << n); 

o

 unsigned long newbit = !!x; // Also booleanize to force 0 or 1 number ^= (-newbit ^ number)  (1UL << n); 

Por lo general, es una buena idea usar tipos sin firma para la manipulación de bits portátil.

En general, también es una buena idea no copiar / pegar el código como un todo, y por lo tanto muchas personas usan macros de preprocesador (por ejemplo, la respuesta de la wiki de la comunidad a continuación ) o algún tipo de encapsulación.

3179
07 сент. Respuesta dada por Jeremy Ruten 07 sep. 2008-09-07 03:50 '08 a las 3:50 am del 2008-09-07 03:50

Usando la biblioteca estándar de C ++: std::bitset<N> .

O Boost : boost::dynamic_bitset .

No hay necesidad de rodar usted mismo:

 #include <bitset> #include <iostream> int main() { std::bitset<5> x; x[1] = 1; x[2] = 0; // Note x[0-4] valid std::cout << x << std::endl; } 
border=0
 [Alpha:] > ./a.out 00010 

La versión Boost le permite establecer el tamaño de bit a bit en comparación con la tasa de bits estándar .

405
18 сент. Respuesta dada por Martin York el 18 de septiembre. 2008-09-18 03:34 '08 a las 3:34 am 2008-09-18 03:34

Otra opción es usar campos de bits:

 struct bits { unsigned int a:1; unsigned int b:1; unsigned int c:1; }; struct bits mybits; 

define un campo de 3 bits (de hecho, estos son tres campos de un bit). Las operaciones de bit son ahora un poco más fáciles (jaja):

Para establecer o borrar un poco:

 mybits.b = 1; mybits.c = 0; 

Para cambiar un poco:

 mybits.a = !mybits.a; mybits.b = ~mybits.b; mybits.c ^= 1;  

Compruebe bit:

 if (mybits.c) //if mybits.c is non zero the next line below will execute 

Esto solo funciona con campos de bits de tamaño fijo. De lo contrario, tendrá que recurrir a los métodos de giro de bits descritos en los mensajes anteriores.

224
11 сент. La respuesta la da Ferruccio 11 sep. 2008-09-11 03:56 '08 a las 3:56 am del 2008-09-11 03:56

Uso macros definidas en el archivo de encabezado para manejar el conjunto de bits y borrar:

  #define BIT_SET(a,b) ((a) |= (1ULL<<(b))) #define BIT_CLEAR(a,b) ((a)  ~(1ULL<<(b))) #define BIT_FLIP(a,b) ((a) ^= (1ULL<<(b))) #define BIT_CHECK(a,b) (!!((a)  (1ULL<<(b)))) // '!!' to make sure this returns 0 or 1  #define BITMASK_SET(x,y) ((x) |= (y)) #define BITMASK_CLEAR(x,y) ((x)  (~(y))) #define BITMASK_FLIP(x,y) ((x) ^= (y)) #define BITMASK_CHECK_ALL(x,y) (((x)  (y)) == (y)) // warning: evaluates y twice #define BITMASK_CHECK_ANY(x,y) ((x)  (y)) 
138
05 нояб. La respuesta está dada por Steve Karg 05 Nov. 2008-11-05 01:35 '08 a la 1:35 am 2008-11-05 01:35

A veces vale la pena usar enum para denotar bits:

 enum ThingFlags = { ThingMask = 0x0000, ThingFlag0 = 1 << 0, ThingFlag1 = 1 << 1, ThingError = 1 << 8, } 

Luego usa los nombres más tarde. Eso es escribir

 thingstate |= ThingFlag1; thingstate  ~ThingFlag0; if (thing  ThingError) {...} 

Instalar, limpiar y comprobar. De esta manera ocultas los números mágicos del resto de tu código.

Además, apoyo la decisión de Jeremy.

106
09 сент. la respuesta se da dmckee 09 sep. 2008-09-09 00:07 '08 a las 0:07 2008-09-09 00:07

Desde snip-c.zip bitops.h:

  typedef enum {ERROR = -1, FALSE, TRUE} LOGICAL; #define BOOL(x) (!(!(x))) #define BitSet(arg,posn) ((arg) | (1L << (posn))) #define BitClr(arg,posn) ((arg)  ~(1L << (posn))) #define BitTst(arg,posn) BOOL((arg)  (1L << (posn))) #define BitFlp(arg,posn) ((arg) ^ (1L << (posn))) 

Bueno, que analice las cosas ...

La expresión general con la que tiene problemas en todos estos casos es "(1L << (posn))". Todo esto crea una máscara con un bit y que funcionará con cualquier tipo de entero. El argumento "posn" indica la posición en la que desea el bit. Si posn == 0, entonces esta expresión será evaluada como:

  0000 0000 0000 0000 0000 0000 0000 0001 binary. 

Si posn == 8, evaluará

  0000 0000 0000 0000 0000 0001 0000 0000 binary. 

En otras palabras, simplemente crea un campo 0 con 1 en la posición especificada. La única parte difícil está en la macro BitClr (), donde necesitamos establecer un bit 0 bit en el campo 1. Esto se logra al agregar una a la misma expresión, que se denota por el operador de tilde (~).

Tan pronto como se crea una máscara, se aplica al argumento de la misma forma que supones, utilizando los operadores a nivel de bits y ( o (|) y xor (^). Como la máscara es de tipo long, las macros funcionarán tan bien como en char, short, int o long.

La conclusión es que esta es una solución común para toda la clase de problemas. Por supuesto, es posible e incluso recomendable volver a escribir el equivalente de cualquiera de estas macros con valores de máscara explícitos cada vez que lo necesite, pero ¿por qué hacerlo? Recuerde que la sustitución de macros se produce en el preprocesador y, por lo tanto, el código generado reflejará el hecho de que el compilador considera que los valores son constantes, es decir, También es efectivo usar macros generalizadas para "reinventar la rueda" cada vez que necesite realizar una manipulación de bits.

¿Convencido? Aquí hay un código de prueba: usé Watcom C con optimización completa y sin usar _cdecl, por lo que el desmontaje resultante sería lo más limpio posible:

---- [TEST.C] ----------------------------------------- -----------------------

 #define BOOL(x) (!(!(x))) #define BitSet(arg,posn) ((arg) | (1L << (posn))) #define BitClr(arg,posn) ((arg)  ~(1L << (posn))) #define BitTst(arg,posn) BOOL((arg)  (1L << (posn))) #define BitFlp(arg,posn) ((arg) ^ (1L << (posn))) int bitmanip(int word) { word = BitSet(word, 2); word = BitSet(word, 7); word = BitClr(word, 3); word = BitFlp(word, 9); return word; } 

---- [TEST.OUT (desmontado)] ---------------------------------------------- ---------

 Module: C:\BINK\tst.c Group: 'DGROUP' CONST,CONST2,_DATA,_BSS Segment: _TEXT BYTE 00000008 bytes 0000 0c 84 bitmanip_ or al,84H ; set bits 2 and 7 0002 80 f4 02 xor ah,02H ; flip bit 9 of EAX (bit 1 of AH) 0005 24 f7 and al,0f7H 0007 c3 ret No disassembly errors 

---- [finis] ------------------------------------------- ----------------------

40
17 сент. respuesta dada por yogeesh el 17 sep . 2008-09-17 05:04 '08 a las 5:04 am del 2008-09-17 05:04

Utilizar operadores bitwise: > |

Para establecer el último bit a 000b :

 foo = foo | 001b 

Para comprobar el último bit en foo :

 if ( foo  001b ) .... 

Para borrar el último bit en foo :

 foo = foo  110b 

Para mayor claridad, utilicé XXXb . Probablemente trabajará con la vista HEX, dependiendo de la estructura de datos en la que empaqueta los bits.

31
07 сент. La respuesta es dada por nsanders Sep 07 2008-09-07 03:45 '08 a las 3:45 am del 2008-09-07 03:45

Para un novato, me gustaría explicar un poco más de ejemplo:

Ejemplo:

 value is 0x55; bitnum : 3rd. 

El operador > se usa para verificar el bit:

 0101 0101  0000 1000 ___________ 0000 0000 (mean 0: False). It will work fine if the third bit is 1 (then the answer will be True) 

Alternar o voltear

 0101 0101 ^ 0000 1000 ___________ 0101 1101 (Flip the third bit without affecting other bits) 
Operador

| : establecer el bit

 0101 0101 | 0000 1000 ___________ 0101 1101 (set the third bit without affecting other bits) 
31
05 июня '12 в 17:18 2012-06-05 17:18 La respuesta es dada por kapilddit el 5 de junio de 2012 a las 17:18 2012-06-05 17:18

Aquí está mi macro aritmética de bits favorita, que funciona para cualquier tipo de matriz de enteros sin signo desde caracteres unsigned char a size_t (que es el tipo más grande que debería ser efectivo para la operación):

 #define BITOP(a,b,op) \ ((a)[(size_t)(b)/(8*sizeof *(a))] op ((size_t)1<<((size_t)(b)%(8*sizeof *(a))))) 

Para establecer el bit:

 BITOP(array, bit, |=); 

Para borrar el bit:

 BITOP(array, bit, > 

Para cambiar un poco:

 BITOP(array, bit, ^=); 

Para comprobar el bit:

 if (BITOP(array, bit,  ... 

y otros

26
13 июля '10 в 9:53 2010-07-13 09:53 la respuesta está dada por R .. 13 de julio de '10 a las 9:53 2010-07-13 09:53

Dado que esto está etiquetado como "integrado", supongo que está utilizando un microcontrolador. Todas las sugerencias anteriores son válidas y funcionan (lectura-modificación-escritura, unión, estructuras, etc.).

Sin embargo, durante un desafío basado en un osciloscopio, me sorprendió descubrir que estos métodos tienen una sobrecarga significativa en el ciclo del procesador en comparación con la escritura del valor directamente en los registros micro PORTnSET / PORTnCLEAR, lo que hace una diferencia real cuando hay bucles ISR / contactos de conmutación de alta frecuencia .

Para aquellos que no están familiarizados: en mi ejemplo, el micro tiene un registro general PORTn, que muestra los pines de salida, por lo que PORTn | = BIT_TO_SET lleva a leer-modificar-escribir en este registro. Sin embargo, los registros PORTnSET / PORTnCLEAR se configuran en "1" para que signifique "haga este bit 1" (SET) o "haga que este bit sea cero" (CLEAR) y "0" signifique "dejar una salida". por lo tanto, obtiene dos puertos, dependiendo de si instala o borra el bit (no siempre es conveniente), pero reacciona mucho más rápido y reduce el código recopilado.

23
14 июня '12 в 18:23 2012-06-14 18:23 La respuesta es dada por John U el 14 de junio de 2012 a las 6:23 p.m 2012/2012 14:23

El enfoque aplicado tiene otras ventajas en el campo incrustado. Puede definir una estructura que se asigna directamente a bits en un registro de hardware particular.

 struct HwRegister { unsigned int errorFlag:1; // one-bit flag field unsigned int Mode:3; // three-bit mode field unsigned int StatusCode:4; // four-bit status code }; struct HwRegister CR3342_AReg; 

Necesita saber el orden de empaquetado de bits: al principio creo que esto es un MSB, pero esto puede depender de la implementación. Además, verifique cómo los campos del controlador de sus controladores cruzan los límites de los bytes.

Luego puedes leer, escribir, probar valores individuales, como antes.

22
06 нояб. La respuesta la da Roddy el 6 de noviembre. 2008-11-06 14:30 '08 a las 14:30 2008-11-06 14:30

Más común para imágenes de mapa de bits de tamaño arbitrario:

 #define BITS 8 #define BIT_SET( p, n) (p[(n)/BITS] |= (0x80>>((n)%BITS))) #define BIT_CLEAR(p, n) (p[(n)/BITS]  ~(0x80>>((n)%BITS))) #define BIT_ISSET(p, n) (p[(n)/BITS]  (0x80>>((n)%BITS))) 
19
14 июня '09 в 0:27 2009-06-14 00:27 la respuesta es dada el 14 de junio de 2009 a las 0:27 2009-06-14 00:27

Compruebe el bit en un lugar arbitrario en una variable de tipo arbitrario:

 #define bit_test(x, y) ( ( ((const char*)  0x80 >> ((y) >> (7-((y) ) ) 

Usando el ejemplo:

 int main(void) { unsigned char arr[8] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF }; for (int ix = 0; ix < 64; ++ix) printf("bit %d is %d\n", ix, bit_test(arr, ix)); return 0; } 

Notas: Está diseñado para ser rápido (dada su flexibilidad) y no ramificado. Esto lleva a un código SPARC eficiente al compilar Sun Studio 8; También lo probé usando MSVC ++ 2008 en amd64. Puede crear macros similares para configurar y borrar bits. La diferencia clave de esta solución en comparación con muchas otras aquí es que funciona para cualquier ubicación en casi cualquier tipo de variable.

18
04 янв. La respuesta es dada por John Zwinck el 4 de enero. 2009-01-04 02:44 '09 a las 2:44 2009-01-04 02:44

Si haces muchos bits, puedes usar máscaras que lo acelerarán todo. Las siguientes funciones son muy rápidas y flexibles (permiten el plegado de bits en mapas de bits de cualquier tamaño).

 const unsigned char TQuickByteMask[8] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, };  void TSetBit( short bit, unsigned char *bitmap) { short n, x; x = bit / 8; // Index to byte. n = bit % 8; // Specific bit in byte. bitmap[x] |= TQuickByteMask[n]; // Set bit. }  void TResetBit( short bit, unsigned char *bitmap) { short n, x; x = bit / 8; // Index to byte. n = bit % 8; // Specific bit in byte. bitmap[x]  (~TQuickByteMask[n]); // Reset bit. }  void TToggleBit( short bit, unsigned char *bitmap) { short n, x; x = bit / 8; // Index to byte. n = bit % 8; // Specific bit in byte. bitmap[x] ^= TQuickByteMask[n]; // Toggle bit. }  short TIsBitSet( short bit, const unsigned char *bitmap) { short n, x; x = bit / 8; // Index to byte. n = bit % 8; // Specific bit in byte. // Test bit (logigal AND). if (bitmap[x]  TQuickByteMask[n]) return 1; return 0; }  short TIsBitReset( short bit, const unsigned char *bitmap) { return TIsBitSet(bit, bitmap) ^ 1; }  int TCountBits( const unsigned char *bitmap, int size) { int i, count = 0; for (i=0; i<size; i++) if (TIsBitSet(i, bitmap)) count++; return count; } 

Nota: para establecer el bit 'n' en un entero de 16 bits, haga lo siguiente:

 TSetBit( n, > 

Depende de usted asegurarse de que el número de bits esté dentro del rango de la tarjeta de bits que está transmitiendo. Tenga en cuenta que para los procesadores endian pequeños, que son bytes, palabras, palabras, palabras, etc. Mostrarse correctamente en la memoria (la razón principal por la que los procesadores endian pequeños son mejores que los procesadores de un gran número, oh, siento que comienza una guerra de fuego en ...).

14
17 сент. La respuesta la da Tim Ring el 17 de septiembre. 2008-09-17 17:10 '08 a las 5:10 pm 2008-09-17 17:10

Este programa está destinado a cambiar cualquier bit de datos de 0 a 1 o de 1 a 0:

 { unsigned int data = 0x000000F0; int bitpos = 4; int bitvalue = 1; unsigned int bit = data; bit = (bit>>bitpos) int invbitvalue = 0x00000001 printf("%x\n",bit); if (bitvalue == 0) { if (bit == 0) printf("%x\n", data); else { data = (data^(invbitvalue<<bitpos)); printf("%x\n", data); } } else { if (bit == 1) printf("elseif %x\n", data); else { data = (data|(bitvalue<<bitpos)); printf("else %x\n", data); } } } 
13
28 февр. La respuesta la da Gokul Naathan el 28 de febrero. 2012-02-28 22:27 '12 a las 10:27 pm 2012-02-28 22:27

Usa esto:

 int ToggleNthBit ( unsigned char n, int num ) { if(num  (1 << n)) num  ~(1 << n); else num |= (1 << n); return num; } 
11
12 апр. Responder thangavel 12 de abril 2009-04-12 02:05 '09 a las 2:05 am 2009-04-12 02:05

bitset respuesta bitset :

 #include <iostream> #include <bitset> #include <string> using namespace std; int main() { bitset<8> byte(std::string("10010011"); // Set Bit byte.set(3); // 10010111 // Clear Bit byte.reset(2); // 10010101 // Toggle Bit byte.flip(7); // 00010101 cout << byte << endl; return 0; } 
10
08 мая '14 в 7:33 2014-05-08 07:33 La respuesta está dada por kendotwill 08 de mayo de 2014 a las 7:33 2014-05-08 07:33

Si desea realizar esta operación con la programación de C en el kernel de Linux, sugiero utilizar las API estándar del kernel de Linux.

Consulte https://www.kernel.org/doc/htmldocs/kernel-api/ch02s03.html.

 set_bit Atomically set a bit in memory clear_bit Clears a bit in memory change_bit Toggle a bit in memory test_and_set_bit Set a bit and return its old value test_and_clear_bit Clear a bit and return its old value test_and_change_bit Change a bit and return its old value test_bit Determine whether a bit is set 

Nota Aquí toda la operación se realiza en un solo paso. Por lo tanto, todos ellos tienen la garantía de ser atómicos, incluso en computadoras SMP y útiles para garantizar la coherencia entre los procesadores.

10
27 мая '16 в 19:41 2016-05-27 19:41 La respuesta la da Jeegar Patel el 27 de mayo de 2016 a las 19:41 2016-05-27 19:41

Visual C 2010 y posiblemente muchos otros compiladores tienen soporte directo para operaciones de bits incrustadas. Sorprendentemente, funciona, incluso el operador sizeof () funciona correctamente.

 bool IsGph[256], IsNotGph[256]; // Initialize boolean array to detect printable characters for(i=0; i<sizeof(IsGph); i++) { IsGph[i] = isgraph((unsigned char)i); } 

Entonces, para su pregunta IsGph [i] = 1 o IsGph [i] = 0, simplifique la configuración y limpieza de bools.

Encuentra caracteres no imprimibles ...

 // Initialize boolean array to detect UN-printable characters, // then call function to toggle required bits true, while initializing a 2nd // boolean array as the complement of the 1st. for(i=0; i<sizeof(IsGph); i++) { if(IsGph[i]) { IsNotGph[i] = 0; } else { IsNotGph[i] = 1; } } 

Tenga en cuenta que este código no es nada especial. Maneja la broca como un todo, lo que técnicamente es. Un entero de 1 bit que puede contener 2 valores y solo 2 valores.

Una vez utilicé este método para buscar registros de crédito duplicados, donde number_name era una clave ISAM, utilizando un número de crédito de 6 dígitos como un índice en una matriz de bits. Inmediatamente e inmediatamente, después de 8 meses, probé que el sistema de mainframe del cual obtuvimos los datos es, de hecho, defectuoso. La simplicidad de los arreglos de bits hace que la confianza en su corrección sea muy alta, por ejemplo, bajo el enfoque de búsqueda.

9
30 дек. La respuesta la da el usuario 1899861 30 de diciembre. 2012-12-30 05:31 '12 a las 5:31 AM 2012-12-30 05:31

Utilice uno de los operadores como se define aquí .

Para establecer el bit, use int x = x | 0x?; int x = x | 0x?; donde ? - Esta es la posición del bit en forma binaria.

6
30 апр. Responder a Jason 30 de abril 2012-04-30 09:48 '12 a las 9:48 2012-04-30 09:48

Aquí hay algunas macros que utilizo:

 SET_FLAG(Status, Flag) ((Status) |= (Flag)) CLEAR_FLAG(Status, Flag) ((Status)  ~(Flag)) INVALID_FLAGS(ulFlags, ulAllowed) ((ulFlags)  ~(ulAllowed)) TEST_FLAGS(t,ulMask, ulBit) (((t) == (ulBit)) IS_FLAG_SET(t,ulMask) TEST_FLAGS(t,ulMask,ulMask) IS_FLAG_CLEAR(t,ulMask) TEST_FLAGS(t,ulMask,0) 
5
07 февр. la respuesta es dada por sam mst 07 feb. 2015-02-07 02:11 '15 a las 2:11 a.m. 2015-02-07 02:11

¿Cómo se configura, borra y cambia un bit?

Para resolver el problema con un error de codificación común al intentar formar una máscara:
1 no siempre 1 lo suficientemente ancho

¿Qué problemas surgen cuando el number es un tipo más ancho que 1 ?
x puede ser demasiado grande para desplazar 1 << x , lo que resulta en un comportamiento indefinido (UB). Incluso si x no x demasiado grande, ~ puede que no gire suficientes bits significativos.

 // assume 32 bit int/unsigned unsigned long long number = foo(); unsigned x = 40; number |= (1 << x); // UB number ^= (1 << x); // UB number  ~(1 << x); // UB x = 10; number  ~(1 << x); // Wrong mask, not wide enough 

Asegurar 1 lo suficientemente ampliamente:

El código se puede utilizar 1ull o (uintmax_t)1 y optimizar el compilador.

 number |= (1ull << x); number |= ((uintmax_t)1 << x); 

O casting: comete errores de codificación / revisión / mantenimiento a la vez que mantiene la precisión y la relevancia.

 number |= (type_of_number)1 << x; 

O avance suavemente 1 , forzando una operación matemática que sea más pequeña que el tipo de number .

 number |= (number*0 + 1) << x; 

Como la mayoría de las manipulaciones de bits, es mejor trabajar con tipos sin firma, no con firma.

4
27 сент. la respuesta se da chux 27 sep 2017-09-27 21:18 '17 a las 21:18 2017-09-27 21:18

La versión de la plantilla de C ++ 11 (colocada en el encabezado):

 namespace bit { template <typename T1, typename T2> inline void set (T1  T2 bit) {variable |= ((T1)1 << bit);} template <typename T1, typename T2> inline void clear(T1  T2 bit) {variable  ~((T1)1 << bit);} template <typename T1, typename T2> inline void flip (T1  T2 bit) {variable ^= ((T1)1 << bit);} template <typename T1, typename T2> inline bool test (T1  T2 bit) {return variable  ((T1)1 << bit);} } namespace bitmask { template <typename T1, typename T2> inline void set (T1  T2 bits) {variable |= bits;} template <typename T1, typename T2> inline void clear(T1  T2 bits) {variable  ~bits;} template <typename T1, typename T2> inline void flip (T1  T2 bits) {variable ^= bits;} template <typename T1, typename T2> inline bool test_all(T1  T2 bits) {return ((variable  bits) == bits);} template <typename T1, typename T2> inline bool test_any(T1  T2 bits) {return variable  bits;} } 
3
10 февр. Respuesta dada por Joakim L. Christiansen el 10 de febrero. 2018-02-10 23:07 '18 a las 23:07 2018-02-10 23:07

Variable utilizada

 int value, pos; 

valor - datos
pos - la posición del bit que queremos establecer, borrar o cambiar
Establecer un poco

 value = value | 1 << pos; 

Poco claro

 value = value  ~(1 << pos); 

Poco de palanca

 value = value ^ 1 << pos; 
3
11 июля '18 в 20:32 2018-07-11 20:32 La respuesta la da Jeet Parikh el 11 de julio de 18 a las 8:32 p. m. 2018-07-11 20:32
 int set_nth_bit(int num, int n){ return (num | 1 << n); } int clear_nth_bit(int num, int n){ return (num  ~( 1 << n)); } int toggle_nth_bit(int num, int n){ return num ^ (1 << n); } int check_nth_bit(int num, int n){ return num  (1 << n); } 
3
21 февр. La respuesta la da Sazzad Hissain Khan el 21 de febrero. 2018-02-21 15:35 '18 a las 3:35 pm 2018-02-21 15:35

Para establecer BitIdx bit en Number en BitValue

 Number = Number xor (1 shl BitIdx) or (BitValue shl BitIdx) 

El truco aquí es primero borrar incondicionalmente el bit BitIdx , especificándolo con 1. Esta versión parece un poco más lenta que con bifurcación ( if bit = 1 then setbit else clearbit ), pero es de una sola línea.

-2
22 мая '17 в 11:24 2017-05-22 11:24 la respuesta se da en Fr0sT el 22 de mayo de 2017 a las 11:24 2017-05-22 11:24

Pruebe una de estas funciones C para cambiar n bits:

 char bitfield; // Start at 0th position void chang_n_bit(int n, int value) { bitfield = (bitfield | (1 << n))  (~( (1 << n) ^ (value << n) )); } 

O

 void chang_n_bit(int n, int value) { bitfield = (bitfield | (1 << n))  ((value << n) | ((~0) ^ (1 << n))); } 

O

 void chang_n_bit(int n, int value) { if(value) bitfield |= 1 << n; else bitfield  ~0 ^ (1 << n); } char get_n_bit(int n) { return (bitfield  (1 << n)) ? 1 : 0; } 
-2
27 мая '14 в 14:46 2014-05-27 14:46 La respuesta se le da a Vincet el 27 de mayo de 2014 a las 14:46 2014-05-27 14:46