Question

I use bitwise to turn bits on and off this way:

unsigned char myChar = ...some value
myChar |= 0x01 << N // turn on the N-th bit

myChar &= ~(0x01 << N) //turn off the N-th bit

Now, suppose the value of N is know but the set/unset operation depends on the value of a bit of another unsigned char.
Since now, I’m doing this way:

if ((otherChar & (0x01 << M)) != 0)
{
    //M-th bit of otherChar is 1
    myChar |= 0x01 << N; 
}else
{
    myChar &= ~(0x01 << N);
}

This should be a sort of “moving bit” operation from an unsigned char to another.

My question:
is there any way of doing this without using the conditional? (and without std::bitset too)

Answer 1

The short answer is “yes”.

The longer answer is that you use the bit directly from the source:

unsigned char bit = 1 << N;

myChar &= ~bit;             // Zero the bit without changing anything else
myChar |= otherChar & bit;  // copy the bit from the source to the destination.

This assumes you want to copy bit N from the source to bit N of the destination. If the source and destination bits might be at different offsets, things get a little more difficult. You have not only extract the correct bit from the source, but you then have to shift it to the correct place, then OR it into the destination. The basic idea is about like above, but the code for shifting is a little tedious. The problem is that you’d like to do something like:

unsigned char temp = source & 1 << M;
temp <<= N - M;
dest |= temp;

This will work fine if N > M, but if M > N, you end up with something like temp <<= -3;. What you’d like would be for a left shift of -3 to end up as a right shift of 3 — but that’s not what happens, so you need some conditional code to take the absolute value and figure out whether to do a right shift or left shift to get the bit from the source into the correct spot in the destination.