Estableciendo un poco

Utilice el operador OR bit a bit (|) para establecer un poco.

number |= 1UL << n;

Eso establecerá el nel poco de number. n debe ser cero, si desea establecer el 1st poco y así sucesivamente hasta n-1, si desea configurar el nth bit.

Utilice la herramienta 1ULL if number es más ancho que unsigned long; Promoción de 1UL << n no sucede hasta después de evaluar 1UL << n donde es un comportamiento indefinido cambiar más que el ancho de un long. Lo mismo se aplica al resto de los ejemplos.

Aclarando un poco

Utilice el operador AND bit a bit (&) para aclarar un poco.

number &= ~(1UL << n);

Eso despejará el nel poco de number. Debe invertir la cadena de bits con el operador NOT bit a bit (~), luego Y eso.

Alternando un poco

El operador XOR (^) se puede utilizar para alternar un poco.

number ^= 1UL << n;

Eso alternará el nel poco de number.

Comprobando un poco

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

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

bit = (number >> n) & 1U;

Eso pondrá el valor de la nel poco de number en la variable bit.

Cambiando el nth bit a x

Configurando el nth bit a cualquiera 1 or 0 se puede lograr con lo siguiente en una implementación de C ++ complementaria a 2:

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

Poco n se establecerá si x is 1y aclarado si x is 0. Si x tiene algún otro valor, obtienes basura. x = !!x lo booleanizará a 0 o 1.

Para hacer esto independiente del comportamiento de negación del complemento a 2 (donde -1 tiene todos los bits establecidos, a diferencia de la implementación de C ++ en complemento a 1 o signo / magnitud), use la negación sin signo.

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

or

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

En general, es una buena idea utilizar tipos sin firmar para la manipulación de bits portátil.

or

number = (number & ~(1UL << n)) | (x << n);

(number & ~(1UL << n)) limpiará el nth bit y (x << n) establecerá el nth bit a x.

También es generalmente una buena idea no copiar / pegar código en general y muchas personas usan macros de preprocesador (como la respuesta wiki de la comunidad más abajo) o algún tipo de encapsulación.

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

O la Boost Versión: boost::dynamic_bitset.

No es necesario enrollar el tuyo:

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

[Alpha:] > ./a.out
00010

La versión Boost permite un conjunto de bits de tamaño de ejecución en comparación con un biblioteca estándar conjunto de bits de tamaño en tiempo de compilación.

La otra opción es utilizar 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 (en realidad, son tres campos de 1 bit). Las operaciones de bits ahora se vuelven un poco (jaja) más simples:

Para establecer o borrar un poco:

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

Para alternar un poco:

mybits.a = !mybits.a;
mybits.b = ~mybits.b;
mybits.c ^= 1;  /* all work */

Comprobando un poco:

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 las técnicas de manipulación de bits descritas en publicaciones anteriores.

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

/* a=target variable, b=bit number to act upon 0-n */
#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

/* x=target variable, y=mask */
#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)))
#define BITMASK_CHECK_ANY(x,y) ((x) & (y))

A veces vale la pena usar un enum a nombre los bits:

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

Entonces usa el nombres mas tarde. Es decir, escribir

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

para configurar, borrar y probar. De esta manera, oculta los números mágicos del resto de su código.

Aparte de eso, apoyo la solución de Jeremy.

Desde recorte-c.zipbitops.h:

/*
**  Bit set, clear, and test operations
**
**  public domain snippet by Bob Stout
*/

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

OK, analicemos las cosas ...

La expresión común con la que parece tener problemas en todos estos es "(1L << (posn))". Todo esto hace es crear una máscara con un solo bit y que funcionará con cualquier tipo de entero. El argumento "posn" especifica la posición en la que desea el bit. Si posn == 0, esta expresión se evaluará como:

0000 0000 0000 0000 0000 0000 0000 0001 binary.

Si posn == 8, se evaluará a:

0000 0000 0000 0000 0000 0001 0000 0000 binary.

En otras palabras, simplemente crea un campo de ceros con un 0 en la posición especificada. La única parte complicada está en la macro BitClr () donde necesitamos establecer un solo bit 1 en un campo de unos. Esto se logra usando el complemento a 0 de la misma expresión indicada por el operador tilde (~).

Una vez que se crea la máscara, se aplica al argumento tal como sugiere, mediante el uso de los operadores bit a bit y (&), o (|) y xor (^). Dado que la máscara es de tipo long, las macros funcionarán igual de bien en char's, short's, int's o long's.

La conclusión es que esta es una solución general para toda una clase de problemas. Por supuesto, es posible e incluso apropiado reescribir el equivalente de cualquiera de estas macros con valores de máscara explícitos cada vez que lo necesite, pero ¿por qué hacerlo? Recuerde, la sustitución de macros ocurre en el preprocesador, por lo que el código generado reflejará el hecho de que los valores son considerados constantes por el compilador, es decir, es tan eficiente usar las macros generalizadas como "reinventar la rueda" cada vez que necesite hacer manipulación de bits.

¿No estás convencido? Aquí hay un código de prueba: utilicé 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] ------------------------------------------- ----------------------

Para el principiante, me gustaría explicar un poco más con un ejemplo:

Ejemplo:

value is 0x55;
bitnum : 3rd.

EL & se utiliza el operador comprobar 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: establece el bit

0101 0101
|
0000 1000
___________
0101 1101 (set the third bit without affecting other bits)

Como esto está etiquetado como "incrustado", asumiré que estás usando un microcontrolador. Todas las sugerencias anteriores son válidas y funcionan (lectura-modificación-escritura, uniones, estructuras, etc.).

Sin embargo, durante una serie de depuración basada en osciloscopios, me sorprendió descubrir que estos métodos tienen una sobrecarga considerable en los ciclos de la CPU en comparación con escribir un valor directamente en los registros PORTnSET / PORTnCLEAR del micro, lo que marca una diferencia real donde hay bucles estrechos / altos -pines de conmutación de ISR de frecuencia.

Para aquellos que no están familiarizados: en mi ejemplo, el micro tiene un registro de estado de pines general PORTn que refleja los pines de salida, por lo que hacer PORTn | = BIT_TO_SET da como resultado una lectura-modificación-escritura en ese registro. Sin embargo, los registros PORTnSET / PORTnCLEAR toman un '1' que significa "por favor haga este bit 1" (SET) o "por favor haga que este bit sea cero" (CLEAR) y un '0' para significar "deje el pin solo". por lo tanto, termina con dos direcciones de puerto dependiendo de si está configurando o borrando el bit (no siempre es conveniente) pero una mucho más reacción más rápida y código ensamblado más pequeño.

Aquí está mi macro aritmética de bits favorita, que funciona para cualquier tipo de matriz de enteros sin signo de unsigned char hasta size_t (que es el tipo más grande con el que debería ser eficiente trabajar):

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

Para establecer un poco:

BITOP(array, bit, |=);

Para aclarar un poco:

BITOP(array, bit, &=~);

Para alternar un poco:

BITOP(array, bit, ^=);

Para probar un poco:

if (BITOP(array, bit, &)) ...

etc.

El enfoque de campo de bits tiene otras ventajas en el ámbito integrado. Puede definir una estructura que se asigne directamente a los bits en un registro de hardware en 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;

Debe conocer el orden de empaquetado de bits; creo que es MSB primero, pero esto puede depender de la implementación. Además, verifique cómo los campos de los controladores del compilador cruzan los límites de bytes.

A continuación, puede leer, escribir y probar los valores individuales como antes.

Verifique un poco en una ubicación arbitraria en una variable de tipo arbitrario:

#define bit_test(x, y)  ( ( ((const char*)&(x))[(y)>>3] & 0x80 >> ((y)&0x07)) >> (7-((y)&0x07) ) )

Uso de la muestra:

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 sin ramificaciones. Da como resultado un código de máquina SPARC eficiente cuando se compila Sun Studio 8; También lo probé usando MSVC ++ 2008 en amd64. Es posible 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 prácticamente cualquier tipo de variable.

Más general, para mapas 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)))

Este programa es para 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)&0x00000001;
    int invbitvalue = 0x00000001&(~bitvalue);
    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);
        }
    }
}

Utilizar esta:

int ToggleNthBit ( unsigned char n, int num )
{
    if(num & (1 << n))
        num &= ~(1 << n);
    else
        num |= (1 << n);

    return num;
}

Si está haciendo muchas tonterías, es posible que desee usar máscaras que harán que todo sea más rápido. Las siguientes funciones son muy rápidas y aún flexibles (permiten manipular bits en mapas de bits de cualquier tamaño).

const unsigned char TQuickByteMask[8] =
{
   0x01, 0x02, 0x04, 0x08,
   0x10, 0x20, 0x40, 0x80,
};


/** Set bit in any sized bit mask.
 *
 * @return    none
 *
 * @param     bit    - Bit number.
 * @param     bitmap - Pointer to bitmap.
 */
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.
}


/** Reset bit in any sized mask.
 *
 * @return  None
 *
 * @param   bit    - Bit number.
 * @param   bitmap - Pointer to bitmap.
 */
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.
}


/** Toggle bit in any sized bit mask.
 *
 * @return   none
 *
 * @param   bit    - Bit number.
 * @param   bitmap - Pointer to bitmap.
 */
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.
}


/** Checks specified bit.
 *
 * @return  1 if bit set else 0.
 *
 * @param   bit    - Bit number.
 * @param   bitmap - Pointer to bitmap.
 */
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;
}


/** Checks specified bit.
 *
 * @return  1 if bit reset else 0.
 *
 * @param   bit    - Bit number.
 * @param   bitmap - Pointer to bitmap.
 */
short TIsBitReset( short bit, const unsigned char *bitmap)
{
    return TIsBitSet(bit, bitmap) ^ 1;
}


/** Count number of bits set in a bitmap.
 *
 * @return   Number of bits set.
 *
 * @param    bitmap - Pointer to bitmap.
 * @param    size   - Bitmap size (in bits).
 *
 * @note    Not very efficient in terms of execution speed. If you are doing
 *        some computationally intense stuff you may need a more complex
 *        implementation which would be faster (especially for big bitmaps).
 *        See (http://graphics.stanford.edu/~seander/bithacks.html).
 */
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;
}

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

TSetBit( n, &my_int);

Depende de usted asegurarse de que el número de bits esté dentro del rango del mapa de bits que pasa. Tenga en cuenta que para los procesadores little endian que bytes, palabras, dwords, qwords, etc., se asignan correctamente entre sí en la memoria (la razón principal por la que los procesadores little endian son 'mejores' que los procesadores big-endian, ah, siento que se avecina una guerra de llamas en...).

Ampliando el bitset responder:

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

Si desea realizar toda esta operación con la programación C en el Kernel Linux luego sugiero usar API estándar del kernel de Linux.

Ver 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 ocurre en un solo paso. Así que todos estos están garantizados para ser atómico incluso en computadoras SMP y son útiles para mantener la coherencia entre procesadores.

Visual C 2010, y quizás muchos otros compiladores, tienen soporte directo para operaciones booleanas integradas. Un bit tiene dos valores posibles, como un booleano, por lo que podemos usar booleanos en su lugar, incluso si ocupan más espacio que un solo bit en memoria en esta representación. Esto funciona, incluso el sizeof() El operador 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, a tu pregunta, IsGph[i] =1o IsGph[i] =0 facilitan el establecimiento y la limpieza de bools.

Para buscar 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 tiene nada de "especial". Se trata un poco como un número entero, que técnicamente lo es. Un entero de 1 bit que puede contener 2 valores y solo 2 valores.

Una vez utilicé este enfoque para encontrar registros de préstamos duplicados, donde número_préstamo era la clave ISAM, usando el número de préstamo de 6 dígitos como índice en la matriz de bits. Salvajemente rápido, y después de 8 meses, demostró que el sistema de mainframe del que estábamos obteniendo los datos estaba funcionando mal. La simplicidad de las matrices de bits hace que la confianza en su exactitud sea muy alta, en comparación con un enfoque de búsqueda, por ejemplo.

Supongamos algunas cosas primero
num = 55 Entero para realizar operaciones bit a bit (establecer, obtener, borrar, alternar).
n = 4 Posición de bit basada en 0 para realizar operaciones bit a bit.

¿Cómo conseguir un poco?

1. Para obtener el nth un poco de desplazamiento numérico a la derecha num, n veces. Luego, realice AND bit a bit. & con 1.

bit = (num >> n) & 1;

¿Cómo funciona?

       0011 0111 (55 in decimal)
    >>         4 (right shift 4 times)
-----------------
       0000 0011
     & 0000 0001 (1 in decimal)
-----------------
    => 0000 0001 (final result)

¿Cómo configurar un poco?

1. Para establecer un número determinado. Desplazamiento a la izquierda 1 n veces. Luego realice OR bit a bit | operación con num.

num |= (1 << n);    // Equivalent to; num = (1 << n) | num;

¿Cómo funciona?

       0000 0001 (1 in decimal)
    <<         4 (left shift 4 times)
-----------------
       0001 0000
     | 0011 0111 (55 in decimal)
-----------------
    => 0001 0000 (final result)

¿Cómo borrar un poco?

1. Desplazamiento a la izquierda 1, n veces es decir 1 << n.
2. Realice un complemento bit a bit con el resultado anterior. De modo que el bit n se desarma y el resto del bit se establece, es decir ~ (1 << n).
3. Finalmente, realice AND bit a bit & operación con el resultado anterior y num. Los tres pasos anteriores juntos se pueden escribir como num & (~ (1 << n));

num &= (~(1 << n));    // Equivalent to; num = num & (~(1 << n));

¿Cómo funciona?

       0000 0001 (1 in decimal)
    <<         4 (left shift 4 times)
-----------------
     ~ 0001 0000
-----------------
       1110 1111
     & 0011 0111 (55 in decimal)
-----------------
    => 0010 0111 (final result)

¿Cómo alternar un poco?

Para alternar un poco usamos XOR bit a bit ^ operador. El operador XOR bit a bit se evalúa como 1 si el bit correspondiente de ambos operandos es diferente; de ​​lo contrario, se evalúa como 0.

Lo que significa que para alternar un poco, necesitamos realizar la operación XOR con el bit que desea alternar y 1.

num ^= (1 << n);    // Equivalent to; num = num ^ (1 << n);

¿Cómo funciona?

• Si el bit para alternar es 0 entonces, 0 ^ 1 => 1.
• Si el bit para alternar es 1 entonces, 1 ^ 1 => 0.

       0000 0001 (1 in decimal)
    <<         4 (left shift 4 times)
-----------------
       0001 0000
     ^ 0011 0111 (55 in decimal)
-----------------
    => 0010 0111 (final result)

Lectura recomendada - Ejercicios de operador bit a bit

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

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)&(ulMask)) == (ulBit))
IS_FLAG_SET(t,ulMask)             TEST_FLAGS(t,ulMask,ulMask)
IS_FLAG_CLEAR(t,ulMask)           TEST_FLAGS(t,ulMask,0)

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

Para solucionar un error de codificación común al intentar formar la máscara:
1 no siempre es lo suficientemente ancho

¿Qué problemas suceden cuando number es un tipo más ancho que 1?
x puede ser demasiado grande para el turno 1 << x llevando a comportamiento indefinido (UB). Incluso si x no es demasiado grande, ~ puede que no invierta suficientes bits más 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

Para asegurarse de que 1 sea lo suficientemente ancho:

El código podría usar 1ull o pedante (uintmax_t)1 y deje que el compilador optimice.

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

O emitir, lo que genera problemas de codificación / revisión / mantenimiento para mantener el reparto correcto y actualizado.

number |= (type_of_number)1 << x;

O promueva suavemente el 1 forzando una operación matemática que sea al menos tan amplia como el tipo de number.

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

Como con la mayoría de las manipulaciones de bits, es mejor trabajar con no firmado tipos en lugar de firmado las

Una versión con plantilla (colocada en un archivo de encabezado) con soporte para cambiar múltiples bits (funciona en microcontroladores AVR por cierto):

namespace bit {
  template <typename T1, typename T2>
  constexpr inline T1 bitmask(T2 bit) 
  {return (T1)1 << bit;}
  template <typename T1, typename T3, typename ...T2>
  constexpr inline T1 bitmask(T3 bit, T2 ...bits) 
  {return ((T1)1 << bit) | bitmask<T1>(bits...);}

  /** Set these bits (others retain their state) */
  template <typename T1, typename ...T2>
  constexpr inline void set (T1 &variable, T2 ...bits) 
  {variable |= bitmask<T1>(bits...);}
  /** Set only these bits (others will be cleared) */
  template <typename T1, typename ...T2>
  constexpr inline void setOnly (T1 &variable, T2 ...bits) 
  {variable = bitmask<T1>(bits...);}
  /** Clear these bits (others retain their state) */
  template <typename T1, typename ...T2>
  constexpr inline void clear (T1 &variable, T2 ...bits) 
  {variable &= ~bitmask<T1>(bits...);}
  /** Flip these bits (others retain their state) */
  template <typename T1, typename ...T2>
  constexpr inline void flip (T1 &variable, T2 ...bits) 
  {variable ^= bitmask<T1>(bits...);}
  /** Check if any of these bits are set */
  template <typename T1, typename ...T2>
  constexpr inline bool isAnySet(const T1 &variable, T2 ...bits) 
  {return variable & bitmask<T1>(bits...);}
  /** Check if all these bits are set */
  template <typename T1, typename ...T2>
  constexpr inline bool isSet (const T1 &variable, T2 ...bits) 
  {return ((variable & bitmask<T1>(bits...)) == bitmask<T1>(bits...));}
  /** Check if all these bits are not set */
  template <typename T1, typename ...T2>
  constexpr inline bool isNotSet (const T1 &variable, T2 ...bits) 
  {return ((variable & bitmask<T1>(bits...)) != bitmask<T1>(bits...));}
}

Ejemplo de uso:

#include <iostream>
#include <bitset> // for console output of binary values

// and include the code above of course

using namespace std;

int main() {
  uint8_t v = 0b1111'1100;
  bit::set(v, 0);
  cout << bitset<8>(v) << endl;

  bit::clear(v, 0,1);
  cout << bitset<8>(v) << endl;

  bit::flip(v, 0,1);
  cout << bitset<8>(v) << endl;

  bit::clear(v, 0,1,2,3,4,5,6,7);
  cout << bitset<8>(v) << endl;

  bit::flip(v, 0,7);
  cout << bitset<8>(v) << endl;
}

Por cierto: resulta que constexpr e inline no se utilizan si no se envía el argumento del optimizador (por ejemplo: -O3) al compilador. No dude en probar el código en https://godbolt.org/ y observe la salida de ASM.

Este programa se basa en la solución anterior de @ Jeremy. Si alguien desea jugar rápidamente.

public class BitwiseOperations {

    public static void main(String args[]) {

        setABit(0, 4); // set the 4th bit, 0000 -> 1000 [8]
        clearABit(16, 5); // clear the 5th bit, 10000 -> 00000 [0]
        toggleABit(8, 4); // toggle the 4th bit, 1000 -> 0000 [0]
        checkABit(8,4); // check the 4th bit 1000 -> true 
    }

    public static void setABit(int input, int n) {
        input = input | ( 1 << n-1);
        System.out.println(input);
    }


    public static void clearABit(int input, int n) {
        input = input & ~(1 << n-1);
        System.out.println(input);
    }

    public static void toggleABit(int input, int n) {
        input = input ^ (1 << n-1);
        System.out.println(input);
    }

    public static void checkABit(int input, int n) {
        boolean isSet = ((input >> n-1) & 1) == 1; 
        System.out.println(isSet);
    }
}


Output :
8
0
0
true

Establecer el bit n en x (valor de bit) sin usar -1

A veces, cuando no está seguro de en qué resultará -1 o similar, es posible que desee establecer el bit n sin usar -1:

number = (((number | (1 << n)) ^ (1 << n))) | (x << n);

Explicación: ((number | (1 << n) establece el bit n en 1 (donde | denota OR bit a bit), luego con (...) ^ (1 << n) establecemos el n-ésimo bit en 0, y finalmente con (...) | x << n) establecemos el enésimo bit que era 0, en (valor de bit) x.

Esto también funciona en golang.

Pruebe una de estas funciones en el lenguaje C para cambiar n bit:

char bitfield;

// Start at 0th position

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

Or

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

Or

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