Comparing Bitfields of Different Sizes

Question

What happens if you use a bitwise operator (&, |, etc.) to compare two bitfields of different sizes?

For example, comparing 0 1 1 0 with 0 0 1 0 0 0 0 1:

0 1 1 0 0 0 0 0 The smaller one is extended with zeros and pushed to the
0 0 1 0 0 0 0 1 most-significant side.

Or...

0 0 0 0 0 1 1 0 The smaller one is extended with zeros and pushed to the
0 0 1 0 0 0 0 1 least-significant side.

Or...

0 1 1 0 The longer one is truncated from its least-significant side,
0 0 1 0 keeping its most significant side.

Or...

0 1 1 0 The longer one is truncated from its most-significant side,
0 0 0 1 keeping its least-significant side.

I used the `C++` tag because I was unsure if this varies from language to language. — Maxpm, Jun 09 '11 at 16:47

Michael Burr · Accepted Answer · 2011-06-09T16:56:05.527

8

The bitwise operators always work on promoted operands. So exactly what might happen can depend on whether one (or both) bitfields are signed (as that may result in sign extension).

So, for your example values, the bit-field with the binary value 0 1 1 0 will be promoted to the int 6, and the bit-field with the binary value 0 0 1 0 0 0 0 1 will be promoted to the int 33, and those are the operands that will be used with whatever the operation is.

edited Jun 09 '11 at 16:56

answered Jun 09 '11 at 16:49

Michael Burr

333,147
50
533
760

So both operands are promoted to a type that can hold the largest of the pair (possibly signed), and then the comparison will be done normally? That would essentially mean the smaller one is extended with zeros and pushed to the larger one's least significant side, correct? – Maxpm Jun 09 '11 at 17:03
@Maxpm: I think that's what it boils down to. For me it's easiest to simply think of the operators as working on `int` (assuming the bit-fields are small enough) rather than thinking through shifts and what not. But different people understand things in different ways... – Michael Burr Jun 09 '11 at 18:17

score 2 · Answer 2 · answered Jun 09 '11 at 17:03

2

0 0 0 0 0 1 1 0 The smaller one is extended with zeros and pushed to the 0 0 1 0 0 0 0 1 least-significant side.

answered Jun 09 '11 at 17:03

Cristian Rodriguez

793
5
16

score 2 · Answer 3 · answered Jun 09 '11 at 17:47

If you're actually using the values as bitfields, what's the meaning of comparing bitfields of different sizes? Would it generate a meaningful result for you?

That said, both operands will be promoted to a minimum size of int/unsigned with signedness depending on the signedness of the original operands. Then these promoted values will be compared with the bitwise operator.

This behaves as your second example: The smaller one is padded with zeroes on the MSB side (pushed to LSB side if you prefer).

If one operand is signed and negative while the other is unsigned, the negative one will be converted to the congruent unsigned number before the bit operation takes place.

If instead of integral numbers you mean std::bitset, you can't do bitwise operations on bitsets of differing sizes.

Comparing Bitfields of Different Sizes

3 Answers3