I have a function implemented which reverses the bits in a number. The number of bits in the number to be reversed can vary. However, of course it must be shifted to the left at the end to align with the nibble if it is not divisible by 4. This is what I have :
uint64_t revBits(uint64_t num)
{
unsigned int counter = 0;
uint64_t reverse_num = 0;
while (num)
{
reverse_num <<= 1;
reverse_num |= num & 1;
num >>= 1;
counter++;
}
if (counter % 4 != 0)
{
reverse_num <<= (4 - counter % 4);
}
return reverse_num;
}
Yes this works. However, is there a cleaner way to do this at the end instead of checking if (counter % 4 != 0)
? Like a one line solution to shift based on the number % 4 without checking if it's 0 first?
Replace
if (counter % 4 != 0)
{
reverse_num <<= (4 - counter % 4);
}
with
reverse_num <<= ((-counter) % 4);
or
reverse_num <<= ((-counter) & 3);
Each pair of parentheses can be omitted if desired.
In addition, it is possible to decrement counter
instead of incrementing it, then (-counter)
can be replaced with counter
at the end.
Be careful if counter
has an unsigned type that is narrower than int
(e.g. if counter
has type unsigned short
and USHRT_MAX <= INT_MAX
). In that case, (-counter)
will be zero or negative, and therefore (-counter) % 4
will be zero or negative, and the shift operation with a negative shift amount will result in undefined behavior. That does not apply in OP's case because counter
has type unsigned int
. Replacing 4
with 4U
would avoid the problem since the negative (-counter)
value would be converted to unsigned int
before the modulo operation, producing a zero or positive shift value. Similarly & 3
could be replaced with & 3U
to avoid problems if int
does not use a two's complement representation of negative values, although it seems unlikely that such implementations ever existed since C23 mandates a two's complement representation of signed integer types.