Question

I’ve got a sequence of bits, say

0110 [1011] 1111

Let’s say I want to set that myddle nybble to 0111 as the new value.

Using a positional masking approach with AND or OR, I seem to have no choice but to first unset the original value to 0000, because if I trying ANDing or ORing against that original value of 1011, I’m not going to come out with the desired result of 0111.

Is there another logical operator I should be using to get the desired effect? Or am I locked into 2 operations every time?

---

The result after kindly assistance was:

inline void foo(Clazz* parent, const Uint8& material, const bool& x, const bool& y, const bool& z)
{
    Uint8 offset = x | (y << 1) | (z << 2); //(0-7)
    Uint64 positionMask = 255 << offset * 8; //255 = length of each entry (8 bits), 8 = number of bits per material entry
    Uint64 value = material << offset * 8;
    parent->childType &= ~positionMask; //flip bits to clear given range.
    parent->childType |= value;
}

…I’m sure this will see further improvement, but this is the (semi-)readable version.

Answer 1

If you happen to already know the current values of the bits, you can XOR:

  0110 1011 1111
^ 0000 1100 0000

= 0110 0111 1111

(where the 1100 needs to be computed first as the XOR between the current bits and the desired bits).

This is, of course, still 2 operations. The difference is that you could precompute the first XOR in certain circumstances.

Other than this special case, there is no other way. You fundamentally need to represent 3 states: set to 1, set to 0, don’t change. You can’t do this with a single binary operand.