Are bitwise operations going to help me to serialize some bools?

Question

I'm not used to binary files, and I'm trying to get the hang of it. I managed to store some integers and unsigned char, and read them without too much pain. Now, when I'm trying to save some booleans, I see that each of my bool takes exactly 1 octet in my file, which seems logical since a lone bool is stored in a char-sized data (correct me if I'm wrong!).

But since I'm going to have 3 or 4 bools to serialize, I figure it is a waste to store them like this : 00000001 00000001 00000000, for instance, when I could have 00000110. I guess to obtain this I should use bitwise operation, but I'm not very good with them... so could somebody tell me:

1. How to store up to 8 bools in a single octet using bitwise manipulations?
2. How to give proper values to (up to 8 bools) from a single octet using bitwise manipulation?
3. (And, bonus question, does anybody can recommend a simple, non-mathematical-oriented-mind like mine, bit manipulation tutorial if this exists? Everything I found I understood but could not put into practice...)

I'm using C++ but I guess most C-syntaxic languages will use the same kind of operation.

Answer 1

To store bools in a byte:

bool flag; // value to store
unsigned char b = 0; // all false
int position; // ranges from 0..7
b = b | (flag << position);

To read it back:

flag = (b & (1 << position));

Answer 2

The easy way is to use std::bitset which allows you to use indexing to access individual bits (bools), then get the resulting value as an integer. It also allows the reverse.

int main() {
  std::bitset<8> s;
  s[1] = s[2] = true;  // 0b_0000_0110
  cout << s.to_ulong() << '\n';
}

Answer 3

Without wrapping in fancy template/pre-processor machinery:

• Set bit 3 in var:
  var |= (1 << 3)
• Set bit n in var:
  var |= (1 << n)
• Clear bit n in var:
  var &= ~(1 << n)
• Test bit n in var: (the !! ensures the result is 0 or 1)
  !!(var & (1 << n))

Answer 4

Try reading this in order.

1. http://www.cprogramming.com/tutorial/bitwise_operators.html

2. http://www-graphics.stanford.edu/~seander/bithacks.html#ConditionalSetOrClearBitsWithoutBranching

Some people willthink that 2nd link is way too hardcore, but once you will master simple manipulation, it will come handy.

Answer 5

Basic stuff first:

• The only combination of bits that means false is 00000000 all the others mean true i.e: 00001000,01010101
• 00000000 = 0(decimal), 00000001 = 2^0, 00000010 = 2^1, 00000100 = 2^2, …. ,10000000 = 2^7

• There is a big difference between the operands (&&, ||) and (&,|) the first ones give the result of the logic operation between the two numbers, for example:

  00000000 && 00000000 = false,

  01010101 && 10101010 = true

  00001100 || 00000000 = true,

  00000000 || 00000000 = false

  The second pair makes a bitwise operation (the logic operation between each bit of the numbers):

  00000000 & 00000000 = 00000000 = false

  00001111 & 11110000 = 00000000 = false

  01010101 & 10101001 = 00000001 = true

  00001111 | 11110000 = 11111111 = true

  00001100 | 00000011 = 00001111 = true

---

To work with this and play with the bits, you only need to know some basic tricks:

• To set a bit to 1 you make the operation | with an octet that has a 1 in that position and ceros in the rest.

For example: we want the first bit of the octet A to be 1 we make: A|00000001

• To set a bit to 0 you make the operation & with an octet that has a 0 in that position and ones in the rest.

For example: we want the last bit of the octet A to be 0 we make: A&01111111

• To get the Boolean value that holds a bit you make the operation & with an octet that has a 1 in that position and ceros in the rest.

For example: we want to see the value of the third bit of the octet A, we make: A&00000100, if A was XXXXX1XX we get 00000100 = true and if A was XXXXX0XX we get 00000000 = false;

Answer 6

You can always serialize bitfields. Something like:

struct bools 
{
    bool a:1;
    bool b:1;
    bool c:1;
    bool d:1;
};

has a sizeof 1