How do you set clear and toggle a single bit

Question

How do you set  clear  and toggle a bit

User · Answer

More general  for arbitrary sized bitmaps    define BITS 8  define BIT SET   p  n   p  n  BITS       0x80 gt  gt   n  BITS     define BIT CLEAR p  n   p  n  BITS   amp     0x80 gt  gt   n  BITS     define BIT ISSET p  n   p  n  BITS   amp     0x80 gt  gt   n  BITS

User · Answer

Setting the nth bit to x  bit value  without using -1 Sometimes when you are not sure what -1 or the like will result in  you may wish to set the nth bit without using -1  number      number    1  lt  lt  n      1  lt  lt  n       x  lt  lt  n    Explanation    number    1  lt  lt  n  sets the nth bit to 1  where   denotes bitwise OR   then with          1  lt  lt  n  we set the nth bit to 0  and finally with         x  lt  lt  n  we set the nth bit that was 0  to  bit value  x  This also works in golang

User · Answer

I use macros defined in a header file to handle bit set and clear     a target variable  b bit number to act upon 0-n     define BIT SET a b    a      1ULL lt  lt  b     define BIT CLEAR a b    a   amp     1ULL lt  lt  b     define BIT FLIP a b    a      1ULL lt  lt  b     define BIT CHECK a b       a   amp   1ULL lt  lt  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   amp      y     define BITMASK FLIP x y    x      y    define BITMASK CHECK ALL x y       x   amp   y     define BITMASK CHECK ANY x y    x   amp   y

User · Answer

A templated version  put in a header file  with support for changing multiple bits  works on AVR microcontrollers btw   namespace bit     template  lt typename T1  typename T2 gt    constexpr inline T1 bitmask T2 bit      return  T1 1  lt  lt  bit     template  lt typename T1  typename T3  typename    T2 gt    constexpr inline T1 bitmask T3 bit  T2    bits      return   T1 1  lt  lt  bit    bitmask lt T1 gt  bits              Set these bits  others retain their state       template  lt typename T1  typename    T2 gt    constexpr inline void set  T1  amp variable  T2    bits      variable    bitmask lt T1 gt  bits             Set only these bits  others will be cleared       template  lt typename T1  typename    T2 gt    constexpr inline void setOnly  T1  amp variable  T2    bits      variable   bitmask lt T1 gt  bits             Clear these bits  others retain their state       template  lt typename T1  typename    T2 gt    constexpr inline void clear  T1  amp variable  T2    bits      variable  amp    bitmask lt T1 gt  bits             Flip these bits  others retain their state       template  lt typename T1  typename    T2 gt    constexpr inline void flip  T1  amp variable  T2    bits      variable    bitmask lt T1 gt  bits             Check if any of these bits are set      template  lt typename T1  typename    T2 gt    constexpr inline bool isAnySet const T1  amp variable  T2    bits      return variable  amp  bitmask lt T1 gt  bits             Check if all these bits are set      template  lt typename T1  typename    T2 gt    constexpr inline bool isSet  const T1  amp variable  T2    bits      return   variable  amp  bitmask lt T1 gt  bits         bitmask lt T1 gt  bits              Check if all these bits are not set      template  lt typename T1  typename    T2 gt    constexpr inline bool isNotSet  const T1  amp variable  T2    bits      return   variable  amp  bitmask lt T1 gt  bits         bitmask lt T1 gt  bits           Example of use   include  lt iostream gt   include  lt bitset gt     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  lt  lt  bitset lt 8 gt  v   lt  lt  endl     bit  clear v  0 1     cout  lt  lt  bitset lt 8 gt  v   lt  lt  endl     bit  flip v  0 1     cout  lt  lt  bitset lt 8 gt  v   lt  lt  endl     bit  clear v  0 1 2 3 4 5 6 7     cout  lt  lt  bitset lt 8 gt  v   lt  lt  endl     bit  flip v  0 7     cout  lt  lt  bitset lt 8 gt  v   lt  lt  endl     BTW  It turns out that constexpr and inline is not used if not sending the optimizer argument  e g   -O3  to the compiler  Feel free to try the code at https   godbolt org  and look at the ASM output

User · Answer

It is sometimes worth using an enum to name the bits   enum ThingFlags       ThingMask    0x0000    ThingFlag0   1  lt  lt  0    ThingFlag1   1  lt  lt  1    ThingError   1  lt  lt  8      Then use the names later on  I e  write   thingstate    ThingFlag1  thingstate  amp    ThingFlag0  if  thing  amp  ThingError          to set  clear and test  This way you hide the magic numbers from the rest of your code    Other than that I endorse Jeremy s solution

User · Answer

This program is to change any data bit from 0 to 1 or 1 to 0         unsigned int data   0x000000F0      int bitpos   4      int bitvalue   1      unsigned int bit   data      bit    bit gt  gt bitpos  amp 0x00000001      int invbitvalue   0x00000001 amp   bitvalue       printf   x n  bit        if  bitvalue    0                if  bit    0              printf   x n   data           else                        data    data  invbitvalue lt  lt bitpos                 printf   x n   data                       else               if  bit    1              printf  elseif  x n   data           else                       data    data  bitvalue lt  lt bitpos                printf  else  x n   data

User · Answer

Visual C 2010  and perhaps many other compilers  have direct support for boolean operations built in  A bit has two possible values  just like a boolean  so we can use booleans instead - even if they take up more space than a single bit in memory in this representation  This works  even the sizeof   operator works properly    bool    IsGph 256   IsNotGph 256        Initialize boolean array to detect printable characters for i 0  i lt sizeof IsGph   i           IsGph i    isgraph  unsigned char i       So  to your question  IsGph i   1  or IsGph i   0 make setting and clearing bools easy   To find unprintable characters       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 lt sizeof IsGph   i           if IsGph i                 IsNotGph i    0          else              IsNotGph i    1            Note there is nothing  special  about this code  It treats a bit like an integer - which technically  it is  A 1 bit integer that can hold 2 values  and 2 values only   I once used this approach to find duplicate loan records  where loan number was the ISAM key  using the 6-digit loan number as an index into the bit array  Savagely fast  and after 8 months  proved that the mainframe system we were getting the data from was in fact malfunctioning  The simplicity of bit arrays makes confidence in their correctness very high - vs a searching approach for example

User · Answer

For the beginner I would like to explain a bit more with an example   Example   value is 0x55  bitnum   3rd    The  amp  operator is used check the bit   0101 0101  amp  0000 1000             0000 0000  mean 0  False   It will work fine if the third bit is 1  then the answer will be True    Toggle or Flip   0101 0101   0000 1000             0101 1101  Flip the third bit without affecting other bits      operator  set the bit  0101 0101   0000 1000             0101 1101  set the third bit without affecting other bits

User · Answer

Here are some macros I use   SET FLAG Status  Flag               Status      Flag   CLEAR FLAG Status  Flag             Status   amp     Flag   INVALID FLAGS ulFlags  ulAllowed    ulFlags   amp    ulAllowed   TEST FLAGS t ulMask  ulBit           t  amp  ulMask       ulBit   IS FLAG SET t ulMask              TEST FLAGS t ulMask ulMask  IS FLAG CLEAR t ulMask            TEST FLAGS t ulMask 0

User · Answer

int set nth bit int num  int n           return  num   1  lt  lt  n      int clear nth bit int num  int n           return  num  amp     1  lt  lt  n       int toggle nth bit int num  int n           return num    1  lt  lt  n      int check nth bit int num  int n           return num  amp   1  lt  lt  n

User · Answer

Try one of these functions in the C language to change n bit   char bitfield      Start at 0th position  void chang n bit int n  int value        bitfield    bitfield    1  lt  lt  n    amp       1  lt  lt  n     value  lt  lt  n          Or  void chang n bit int n  int value        bitfield    bitfield    1  lt  lt  n    amp    value  lt  lt  n       0     1  lt  lt  n         Or  void chang n bit int n  int value        if value          bitfield    1  lt  lt  n      else         bitfield  amp    0    1  lt  lt  n      char get n bit int n        return  bitfield  amp   1  lt  lt  n     1   0

User · Answer

Expanding on the bitset answer    include  lt iostream gt   include  lt bitset gt   include  lt string gt   using namespace std  int main       bitset lt 8 gt  byte std  string  10010011          Set Bit   byte set 3      10010111       Clear Bit   byte reset 2      10010101       Toggle Bit   byte flip 7      00010101    cout  lt  lt  byte  lt  lt  endl     return 0

User · Answer

Setting a bit Use the bitwise OR operator     to set a bit  number    1UL  lt  lt  n   That will set the nth bit of number  n should be zero  if you want to set the 1st bit and so on upto n-1  if you want to set the nth bit  Use 1ULL if number is wider than unsigned long  promotion of 1UL  lt  lt  n doesn t happen until after evaluating 1UL  lt  lt  n where it s undefined behaviour to shift by more than the width of a long   The same applies to all the rest of the examples  Clearing a bit Use the bitwise AND operator   amp   to clear a bit  number  amp     1UL  lt  lt  n    That will clear the nth bit of number  You must invert the bit string with the bitwise NOT operator      then AND it  Toggling a bit The XOR operator     can be used to toggle a bit  number    1UL  lt  lt  n   That will toggle the nth bit of number  Checking a bit You didn t ask for this  but I might as well add it  To check a bit  shift the number n to the right  then bitwise AND it  bit    number  gt  gt  n   amp  1U   That will put the value of the nth bit of number into the variable bit  Changing the nth bit to x Setting the nth bit to either 1 or 0 can be achieved with the following on a 2 s complement C   implementation  number     -x   number   amp   1UL  lt  lt  n    Bit n will be set if x is 1  and cleared if x is 0   If x has some other value  you get garbage   x     x will booleanize it to 0 or 1  To make this independent of 2 s complement negation behaviour  where -1 has all bits set  unlike on a 1 s complement or sign magnitude C   implementation   use unsigned negation  number     - unsigned long x   number   amp   1UL  lt  lt  n    or unsigned long newbit     x        Also booleanize to force 0 or 1 number     -newbit   number   amp   1UL  lt  lt  n    It s generally a good idea to use unsigned types for portable bit manipulation  or number    number  amp    1UL  lt  lt  n      x  lt  lt  n     number  amp    1UL  lt  lt  n   will clear the nth bit and  x  lt  lt  n  will set the nth bit to x  It s also generally a good idea to not to copy paste code in general and so many people use preprocessor macros  like the community wiki answer further down  or some sort of encapsulation

User · Answer

How do you set  clear  and toggle a single bit    To address a common coding pitfall when attempting to form the mask  1 is not always wide enough  What problems happen when number is a wider type than 1  x may be too great for the shift 1  lt  lt  x leading to undefined behavior  UB    Even if x is not too great    may not flip enough most-significant-bits      assume 32 bit int unsigned unsigned long long number   foo     unsigned x   40   number     1  lt  lt  x       UB number     1  lt  lt  x       UB number  amp     1  lt  lt  x      UB  x   10  number  amp     1  lt  lt  x      Wrong mask  not wide enough     To insure 1 is wide enough   Code could use 1ull or pedantically  uintmax t 1 and let the compiler optimize   number     1ull  lt  lt  x   number      uintmax t 1  lt  lt  x     Or cast - which makes for coding review maintenance issues keeping the cast correct and up-to-date   number     type of number 1  lt  lt  x    Or gently promote the 1 by forcing a math operation that is as least as wide as the type of number   number     number 0   1   lt  lt  x      As with most bit manipulations  best to work with unsigned types rather than signed ones

User · Answer

If you re doing a lot of bit twiddling you might want to use masks which will make the whole thing quicker  The following functions are very fast and are still flexible  they allow bit twiddling in bit maps of any size    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   amp     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   amp  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 lt size  i            if  TIsBitSet i  bitmap               count         return count      Note  to set bit  n  in a 16 bit integer you do the following   TSetBit  n   amp my int     It s up to you to ensure that the bit number is within the range of the bit map that you pass  Note that for little endian processors that bytes  words  dwords  qwords  etc   map correctly to each other in memory  main reason that little endian processors are  better  than big-endian processors  ah  I feel a flame war coming on

User · Answer

Use this   int ToggleNthBit   unsigned char n  int num         if num  amp   1  lt  lt  n           num  amp     1  lt  lt  n       else         num     1  lt  lt  n        return num

User · Answer

Here s my favorite bit arithmetic macro  which works for any type of unsigned integer array from unsigned char up to size t  which is the biggest type that should be efficient to work with     define BITOP a b op       a   size t  b   8 sizeof   a    op   size t 1 lt  lt   size t  b   8 sizeof   a        To set a bit   BITOP array  bit         To clear a bit   BITOP array  bit   amp        To toggle a bit   BITOP array  bit         To test a bit   if  BITOP array  bit   amp          etc

User · Answer

Check a bit at an arbitrary location in a variable of arbitrary type    define bit test x  y         const char   amp  x    y  gt  gt 3   amp  0x80  gt  gt    y  amp 0x07    gt  gt   7-  y  amp 0x07        Sample usage   int main void        unsigned char arr 8      0x01  0x23  0x45  0x67  0x89  0xAB  0xCD  0xEF         for  int ix   0  ix  lt  64    ix          printf  bit  d is  d n   ix  bit test arr  ix         return 0      Notes  This is designed to be fast  given its flexibility  and non-branchy   It results in efficient SPARC machine code when compiled Sun Studio 8  I ve also tested it using MSVC   2008 on amd64   It s possible to make similar macros for setting and clearing bits   The key difference of this solution compared with many others here is that it works for any location in pretty much any type of variable

User · Answer

If you want to perform this all operation with C programming in the Linux kernel then I suggest to use standard APIs of the Linux kernel   See 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   Note  Here the whole operation happens in a single step  So these all are  guaranteed to be atomic even on SMP computers and are useful to keep coherence across processors

User · Answer

Using the Standard C   Library  std  bitset lt N gt    Or the Boost version  boost  dynamic bitset   There is no need to roll your own    include  lt bitset gt   include  lt iostream gt   int main         std  bitset lt 5 gt  x       x 1    1      x 2    0         Note x 0-4   valid      std  cout  lt  lt  x  lt  lt  std  endl         Alpha    gt    a out 00010   The Boost version allows a runtime sized bitset compared with a standard library compile-time sized bitset

User · Answer

The other option is to use bit fields   struct bits       unsigned int a 1      unsigned int b 1      unsigned int c 1      struct bits mybits    defines a 3-bit field  actually  it s three 1-bit felds   Bit operations now become a bit  haha  simpler   To set or clear a bit   mybits b   1  mybits c   0    To toggle a bit   mybits a    mybits a  mybits b    mybits b  mybits c    1      all work      Checking a bit   if  mybits c     if mybits c is non zero the next line below will execute   This only works with fixed-size bit fields  Otherwise you have to resort to the bit-twiddling techniques described in previous posts

User · Answer

The bitfield approach has other advantages in the embedded arena  You can define a struct that maps directly onto the bits in a particular hardware register   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    You need to be aware of the bit packing order - I think it s MSB first  but this may be implementation-dependent  Also  verify how your compiler handlers fields crossing byte boundaries   You can then read  write  test the individual values as before

User · Answer

From snip-c zip s bitops 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  lt  lt   posn     define BitClr arg posn    arg   amp    1L  lt  lt   posn     define BitTst arg posn  BOOL  arg   amp   1L  lt  lt   posn     define BitFlp arg posn    arg     1L  lt  lt   posn      OK  let s analyze things     The common expression that you seem to be having problems with in all of these is   1L  lt  lt   posn     All this does is create a mask with a single bit on and which will work with any integer type  The  posn  argument specifies the position where you want the bit  If posn  0  then this expression will evaluate to   0000 0000 0000 0000 0000 0000 0000 0001 binary    If posn  8  it will evaluate to   0000 0000 0000 0000 0000 0001 0000 0000 binary    In other words  it simply creates a field of 0 s with a 1 at the specified position  The only tricky part is in the BitClr   macro where we need to set a single 0 bit in a field of 1 s  This is accomplished by using the 1 s complement of the same expression as denoted by the tilde     operator   Once the mask is created it s applied to the argument just as you suggest  by use of the bitwise and   amp    or      and xor     operators  Since the mask is of type long  the macros will work just as well on char s  short s  int s  or long s   The bottom line is that this is a general solution to an entire class of problems  It is  of course  possible and even appropriate to rewrite the equivalent of any of these macros with explicit mask values every time you need one  but why do it  Remember  the macro substitution occurs in the preprocessor and so the generated code will reflect the fact that the values are considered constant by the compiler - i e  it s just as efficient to use the generalized macros as to  reinvent the wheel  every time you need to do bit manipulation    Unconvinced  Here s some test code - I used Watcom C with full optimization and without using  cdecl so the resulting disassembly would be as clean as possible   ----  TEST C  ----------------------------------------------------------------   define BOOL x       x      define BitSet arg posn    arg     1L  lt  lt   posn     define BitClr arg posn    arg   amp    1L  lt  lt   posn     define BitTst arg posn  BOOL  arg   amp   1L  lt  lt   posn     define BitFlp arg posn    arg     1L  lt  lt   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  disassembled   -----------------------------------------------  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  -----------------------------------------------------------------

User · Answer

This program is based out of  Jeremy s above solution  If someone wish to quickly play around   public class BitwiseOperations        public static void main String args               setABit 0  4      set the 4th bit  0000 - gt  1000  8          clearABit 16  5      clear the 5th bit  10000 - gt  00000  0          toggleABit 8  4      toggle the 4th bit  1000 - gt  0000  0          checkABit 8 4      check the 4th bit 1000 - gt  true             public static void setABit int input  int n            input   input     1  lt  lt  n-1           System out println input               public static void clearABit int input  int n            input   input  amp    1  lt  lt  n-1           System out println input              public static void toggleABit int input  int n            input   input    1  lt  lt  n-1           System out println input              public static void checkABit int input  int n            boolean isSet     input  gt  gt  n-1   amp  1     1           System out println isSet             Output   8 0 0 true

User · Answer

As this is tagged  embedded  I ll assume you re using a microcontroller  All of the above suggestions are valid  amp  work  read-modify-write  unions  structs  etc     However  during a bout of oscilloscope-based debugging I was amazed to find that these methods have a considerable overhead in CPU cycles compared to writing a value directly to the micro s PORTnSET   PORTnCLEAR registers which makes a real difference where there are tight loops   high-frequency ISR s toggling pins   For those unfamiliar  In my example  the micro has a general pin-state register PORTn which reflects the output pins  so doing PORTn    BIT TO SET results in a read-modify-write to that register  However  the PORTnSET   PORTnCLEAR registers take a  1  to mean  please make this bit 1   SET  or  please make this bit zero   CLEAR  and a  0  to mean  leave the pin alone   so  you end up with two port addresses depending whether you re setting or clearing the bit  not always convenient  but a much faster reaction and smaller assembled code

User · Answer

Let suppose few things first   num   55 Integer to perform bitwise operations  set  get  clear  toggle     n   4 0 based bit position to perform bitwise operations       How to get a bit    To get the nth bit of num right shift num  n times  Then perform bitwise AND  amp  with 1    bit    num  gt  gt  n   amp  1    How it works          0011 0111  55 in decimal       gt  gt          4  right shift 4 times  -----------------        0000 0011       amp  0000 0001  1 in decimal  -----------------       gt  0000 0001  final result    How to set a bit    To set a particular bit of number  Left shift 1 n times  Then perform bitwise OR   operation with num    num     1  lt  lt  n         Equivalent to  num    1  lt  lt  n    num    How it works          0000 0001  1 in decimal       lt  lt          4  left shift 4 times  -----------------        0001 0000        0011 0111  55 in decimal  -----------------       gt  0001 0000  final result    How to clear a bit    Left shift 1  n times i e  1  lt  lt  n  Perform bitwise complement with the above result  So that the nth bit becomes unset and rest of bit becomes set i e     1  lt  lt  n   Finally  perform bitwise AND  amp  operation with the above result and num  The above three steps together can be written as num  amp      1  lt  lt  n        num  amp      1  lt  lt  n          Equivalent to  num   num  amp     1  lt  lt  n      How it works          0000 0001  1 in decimal       lt  lt          4  left shift 4 times  -----------------        0001 0000 -----------------        1110 1111       amp  0011 0111  55 in decimal  -----------------       gt  0010 0111  final result    How to toggle a bit   To toggle a bit we use bitwise XOR   operator  Bitwise XOR operator evaluates to 1 if corresponding bit of both operands are different  otherwise evaluates to 0     Which means to toggle a bit  we need to perform XOR operation with the bit you want to toggle and 1    num     1  lt  lt  n         Equivalent to  num   num    1  lt  lt  n     How it works     If the bit to toggle is 0 then  0   1   gt  1    If the bit to toggle is 1 then  1   1   gt  0           0000 0001  1 in decimal       lt  lt          4  left shift 4 times  -----------------        0001 0000        0011 0111  55 in decimal  -----------------       gt  0010 0111  final result    Recommended reading - Bitwise operator exercises

[c++] How do you set, clear, and toggle a single bit?

Examples related to c++

Examples related to c

Examples related to bit-manipulation

Examples related to bitwise-operators