# storing bits in char

Hi,

My friend wrote me this piece of code but he didn’t explain it very well. I have 16 bits of information that are either 0 or 1, so he stored it in char[8] and he gets them back using:

``````int getWhite(char * whites, int led) {
return (whites[led / 8] & (1 << (7 - (led % 8)) == 0) ? 0 : 1;
}
``````

i have no idea how to interpret that or to see what’s going on. i would appreciate it someone helped break it down for me.

thanks

have 16 bits of information that are either 0 or 1, so he stored it in char[8]

Storing 16 bits in a structure capable of storing 64 is wasteful.

``````whites[led / 8] & (1 << (7 - (led % 8)) == 0) ? 0 : 1
``````

“led % 8” is the remainder when you divide the value “led” by 8.
Thus, if “led” is 10, led / 8 = 1, and led % 8 = 2
so “led / 8” addresses the second byte in your array, and “led % 8” gives you the position of the bit you want within that byte.

The rest just sets up a bitmask to extract that bit.

& (1 << (7 - (led % 8)) == 0) ? 0 : 1

“1 <<” means shift a single bit left by the number of places after the “<<” operator.
so, 1 << 1 = 10 (in binary) or decimal 2.
1 << 0 = 1
1 << 2 = 4

These allow you to isolate a single bit.

The “?” operator evaluate the expression to its left, and if true, returns the first of its operands (here “0”), otherwise it returns the rightmost (after the “:”), here “1”.

Thus "(3 == (1 + 2) ? “A” : “B” "
would return the string “A”.

i think i sort of get it. if whites[0] or whites[1] is empty, then it is 0 and because of the bitwise AND operator, it will return 0 and the whole thing is 0.

when it isn’t empty, the first part of the compare is 1. then we go on to check the bit which is led % 8. but i don’t get how shifting 1 left a certain number of places returns the bit value.

1<<0 = 1
1<<1 = 2
1<<2 = 4

1<<n is always bigger than 0. so doesn’t that always return true as long as the whites[0] and whites[1] isn’t empty? maybe i’m getting a bit confused here. if:

whites[0] = B10100000;

then whites[0] is not empty. and say we want the third bit (we count from the LSB on the right, yes?) so then

(1 << (7 - (led % 8))
is
(1 << (7 - 3)) = 1 << 4 = 16 > 0.

1 & 16 = 1, so the function would return 1 (i mean it shouldn’t).

where have i gone wrong?

1<<n is always bigger than 0. so doesn’t that always return true

You’ve missed out the bitwise logical AND operator “&”.

If you’ve got a byte that contains a value, a simple test for odd or even is “value & 1”.
This ANDs “value” with 1.
If the least significant bit of value is a “1”, this expression will evaluate true, because “1 & 1 = 1”.
“value” is thus odd.

If the least significant bit is a zero, “1 & 0 = 0”, so “value” is even.

Thus “1 << x” isolates a single bit, and the “&” operation tests that bit.

Remember, whites [0] contains bits 0…7, whites [1] contains bits 8…15.

Incidentally, “led % 8” can also be written “led & 7” * - I’ll leave you to figure out how

• For positive “led”