How to read write arbitrary bits in C C

Question

Assuming I have a byte b with the binary value of 11111111  How do I for example read a 3 bit integer value starting at the second bit or write a four bit integer value starting at the fifth bit

User · Answer

If you keep grabbing bits from your data, you might want to use a bitfield. You'll just have to set up a struct and load it with only ones and zeroes:

struct bitfield{
    unsigned int bit : 1
}
struct bitfield *bitstream;

then later on load it like this (replacing char with int or whatever data you are loading):

long int i;
int j, k;
unsigned char c, d;

bitstream=malloc(sizeof(struct bitfield)*charstreamlength*sizeof(char));
for (i=0; i<charstreamlength; i++){
    c=charstream[i];
    for(j=0; j < sizeof(char)*8; j++){
        d=c;
        d=d>>(sizeof(char)*8-j-1);
        d=d<<(sizeof(char)*8-1);
        k=d;
        if(k==0){
            bitstream[sizeof(char)*8*i + j].bit=0;
        }else{
            bitstream[sizeof(char)*8*i + j].bit=1;
        }
    }
}

Then access elements:

bitstream[bitpointer].bit=...

or

...=bitstream[bitpointer].bit

All of this is assuming are working on i86/64, not arm, since arm can be big or little endian.

User · Answer

int x   0xFF      your number - 11111111      How do I for example read a 3 bit integer value starting at the second bit   int y   x  amp    0x7  lt  lt  2      0x7 is 111                             and you shift it 2 to the left

User · Answer

To read bytes use std  bitset  const int bits in byte   8   char myChar    s   cout  lt  lt  bitset lt sizeof myChar    bits in byte gt  myChar     To write you need to use bit-wise operators such as  amp       amp   lt  lt      make sure to learn what they do   For example to have 00100100 you need to set the first bit to 1  and shift it with the  lt  lt     operators 5 times  if you want to continue writing you just continue to set the first bit and shift it  it s very much like an old typewriter  you write  and shift the paper   For 00100100  set the first bit to 1  shift 5 times  set the first bit to 1  and shift 2 times   const int bits in byte   8   char myChar   0  myChar   myChar    0x1  lt  lt  5   0x1  lt  lt  2   cout  lt  lt  bitset lt sizeof myChar    bits in byte gt  myChar

User · Answer

just use this and feelfree    define BitVal data y     data gt  gt y   amp  1           Return Data Y value        define SetBit data y     data     1  lt  lt  y         Set Data Y   to 1         define ClearBit data y   data  amp     1  lt  lt  y        Clear Data Y to 0         define TogleBit data y       data   BitVal y           Togle Data Y  value       define Togle data     data   data               Togle Data value           for example   uint8 t number   0x05    0b00000101 uint8 t bit 2   BitVal number 2      bit 2   1 uint8 t bit 1   BitVal number 1      bit 1   0  SetBit number 1      number    0x07   gt  0b00000111 ClearBit number 2      number  0x03   gt  0b0000011

User · Answer

You have to do a shift and mask  AND  operation  Let b be any byte and p be the index     0  of the bit from which you want to take n bits     1    First you have to shift right b by p times   x   b  gt  gt  p    Second you have to mask the result with n ones   mask    1  lt  lt  n  - 1  y   x  amp  mask    You can put everything in a macro    define TAKE N BITS FROM b  p  n    b   gt  gt   p    amp    1  lt  lt   n   - 1

User · Answer

Some 2  years after I asked this question I d like to explain it the way I d want it explained back when I was still a complete newb and would be most beneficial to people who want to understand the process  First of all  forget the  quot 11111111 quot  example value  which is not really all that suited for the visual explanation of the process  So let the initial value be 10111011  187 decimal  which will be a little more illustrative of the process  1 - how to read a 3 bit value starting from the second bit            lt - those 3 bits 10111011   The value is 101  or 5 in decimal  there are 2 possible ways to get it   mask and shift  In this approach  the needed bits are first masked with the value 00001110  14 decimal  after which it is shifted in place          10111011 AND 00001110   00001010  gt  gt  1            00000101  The expression for this would be   value  amp  14   gt  gt  1  shift and mask  This approach is similar  but the order of operations is reversed  meaning the original value is shifted and then masked with 00000111  7  to only leave the last 3 bits          10111011  gt  gt  1          01011101 AND 00000111 00000101  The expression for this would be   value  gt  gt  1   amp  7 Both approaches involve the same amount of complexity  and therefore will not differ in performance  2 - how to write a 3 bit value starting from the second bit  In this case  the initial value is known  and when this is the case in code  you may be able to come up with a way to set the known value to another known value which uses less operations  but in reality this is rarely the case  most of the time the code will know neither the initial value  nor the one which is to be written  This means that in order for the new value to be successfully  quot spliced quot  into byte  the target bits must be set to zero  after which the shifted value is  quot spliced quot  in place  which is the first step           10111011 AND 11110001  241    10110001  masked original value   The second step is to shift the value we want to write in the 3 bits  say we want to change that from 101  5  to 110  6           00000110  lt  lt  1           00001100  shifted  quot splice quot  value   The third and final step is to splice the masked original value with the shifted  quot splice quot  value  10110001 OR 00001100           10111101  The expression for the whole process would be   value  amp  241     6  lt  lt  1  Bonus - how to generate the read and write masks  Naturally  using a binary to decimal converter is far from elegant  especially in the case of 32 and 64 bit containers - decimal values get crazy big  It is possible to easily generate the masks with expressions  which the compiler can efficiently resolve during compilation   read mask for  quot mask and shift quot     1  lt  lt  fieldLength  - 1   lt  lt   fieldIndex - 1   assuming that the index at the first bit is 1  not zero  read mask for  quot shift and mask quot    1  lt  lt  fieldLength  - 1  index does not play a role here since it is always shifted to the first bit write mask   just invert the  quot mask and shift quot  mask expression with the   operator  How does it work  with the 3bit field beginning at the second bit from the examples above   00000001  lt  lt  3 00001000  - 1 00000111  lt  lt  1 00001110     read mask  11110001     write mask   The same examples apply to wider integers and arbitrary bit width and position of the fields  with the shift and mask values varying accordingly  Also note that the examples assume unsigned integer  which is what you want to use in order to use integers as portable bit-field alternative  regular bit-fields are in no way guaranteed by the standard to be portable   both left and right shift insert a padding 0  which is not the case with right shifting a signed integer  Even easier  Using this set of macros  but only in C   since it relies on the generation of member functions    define GETMASK index  size      size t 1  lt  lt   size   - 1   lt  lt   index    define READFROM data  index  size     data   amp  GETMASK  index    size     gt  gt   index    define WRITETO data  index  size  value    data       data   amp    GETMASK  index    size          value   lt  lt   index    amp   GETMASK  index    size        define FIELD data  name  index  size      inline decltype data  name   const   return READFROM data  index  size         inline void set   name decltype data  value    WRITETO data  index  size  value      You could go for something as simple as  struct A     uint bitData    FIELD bitData  one  0  1    FIELD bitData  two  1  2      And have the bit fields implemented as properties you can easily access  A a  a set two 3   cout  lt  lt  a two     Replace decltype with gcc s typeof pre-C  11

User · Answer

You need to shift and mask the value  so for example     If you want to read the first two bits  you just need to mask them off like so   int value   input  amp  0x3    If you want to offset it you need to shift right N bits and then mask off the bits you want   int value    intput  gt  gt  1   amp  0x3    To read three bits like you asked in your question   int value    input  gt  gt  1   amp  0x7

User · Answer

How do I for example read a 3 bit integer value starting at the second bit    int number      whatever  uint8 t val     uint8 t is the smallest data type capable of holding 3 bits val    number  amp   1  lt  lt  2   1  lt  lt  3   1  lt  lt  4    gt  gt  2     I assumed that  second bit  is bit  2  i  e  the third bit really

[c++] How to read/write arbitrary bits in C/C++

Examples related to c++

Examples related to c

Examples related to memory

Examples related to bit

Examples related to read-write