Unions in c++ and bitwise operations - c++

Question

I have seen the following structure in a source code.
template<unsigned bitno, unsigned nbits = 1, typename T = u8>
struct RegBit
{
T data;
enum { mask = (1u << nbits) - 1u };
template<typename T2>
RegBit& operator=(T2 val)
{
data = (data & ~(mask << bitno)) | ((nbits > 1 ? val & mask : !!val) << bitno);
return *this;
}
operator unsigned() const { return (data >> bitno) & mask; }
};
union {
u8 raw;
RegBit<0> r0;
RegBit<1> r1;
RegBit<2> r2;
RegBit<3> r3;
RegBit<6> r6;
RegBit<7> r7;
} P;
After a first reading, I found out that an unsigned cast of an object whose type is RegBit will return the bit number bitno + 1 of data.
However, I don't understand how the = overloaded operator is handled. I mean that I understand the syntax, but not what the bitwise operation is meant to do.
And last thing, if you run the code and affect a value to P.raw, you'll notice that ∀ i ∈ [0;7], P.ri.data = P.raw.
How is that possible ?
Of course then, the code does what it's suppose to do imho, ie: ∀ i ∈ [0;7], (unsigned)P.ri is the (i+1)th bit of P.raw.

Answer 1

How does the operator= work ?
When you write P.r2 = 1; , the assignment operator for the r2 member gets invoked. So it would have the effect of P.r2.operator= (1); which returns a reference to P.r2.
Let's analyze the assignment details in the specialized template with bitno=2, nbits=1 and T being u8:
mask = (1u << nbits) - 1u
= (1 shifted by 1 bits, aka binary 10) - 1
= binary 1 (i.e. it's a binary number with the n lowest bits set)
Let's analyse the full expression step by step. First the left part:
mask << bitno ===> binary 100
~(mask << bitno) ===> binary 1..1011 (aka the bit bitno is set to 0, counting from least significant bit)
(data & ~(mask << bitno)) ===> the bit bitno is set to 0 in data (thanks to the bitwise &)
Now the right part of the expression:
(nbits > 1 ? val & mask : !!val) is a conditional operator:
if nbits >1 is true, then it's val&mask, aka the n lowest bits of val
if not, then it's !!val, aka "not not val" which evalauates to 0 if val is 0 and 1 if val is not 0.
In our case, it's the second alternative so 0 or 1 depending on val.
((nbits > 1 ? val & mask : !!val) << bitno) then shifts the 0 or the 1 by 2 bits.
Now finally combining all this:
data = (data & ~(mask << bitno)) | ((nbits > 1 ? val & mask : !!val) << bitno);
= (data with the bit bitno set to 0) ored with (val expressed on one bit in the bit bitno, counting from the least significant )
Otherwise stated, as a bit value 0 ored with a bit value x gives as results a bit value x, this expression sets the bit bitno to val (val being handled as a bool).
But what is the union supposed to do ?
The union handles all its members (which are all of the same type u8) in the same memory location.
So what would be according to you the expected output of the following:
P.raw=0;
P.r2=1;
P.r3=0;
P.r4=1;
cout << (int)P.raw <<endl;
The optimist who wrote your code snippet certainly expects a result of 20 (aka binary 10100). That may work like this on many compilers. But in reality this is ABSOLUTELY NOT GUARANTEED according to the standard:
9.5/1: In a union, at most one of the non-static data members can be active at any time, that is, the value of at most one of the
non-static data members can be stored in a union at any time.
Otherwise stated, if you store something in r2 you're not sure that you will find back the same value in r4. The only thing that is sure is that if you store something in r2 and do not store anything else in the other members, you'll find back in r2 what you've stored there.
Alternatives to the union
If you need to ensure portability, you could consider using either std::bitset or standard bitfields.