如何在不丢失位的情况下执行c的移位？

Question

In C when you do something like this:

char var = 1;

while(1)
{
  var = var << 1;
}

In the 8th iteration the "<<" operator will shift out the 1 and var will be 0. I need to perform a shift in order to mantain the bit shifting. In other words I need this:

initial ----- 00000001

1st shift -- 00000010

2nd shift - 00000100

3rd shift - 00001000

4th shift - 00010000

5th shift -- 00100000

6th shift -- 01000000

7th shift - 10000000

8th shift - 00000001 (At the 8th shift the one automatically start again)

Is there something equivalent to "<<" but to achieve this?

Answer 1

This is known as a circular shift , but C doesn't offer this functionality at the language level.

You will either have to implement this yourself, or resort to inline assembler routines, assuming your platform natively has such an instruction.

For example:

var = (var << 1) | (var >> 7);

(This is not well-defined for negative signed types, though, so you'd have to change your example to unsigned char .)

Answer 2

Yes, you can use a circular shift . (Although it isn't a built-in C operation, but it is a CPU instruction on x86 CPUs)

Answer 3

So you want to do a bit rotation, aka circular shift, then.

#include <limits.h>   // Needed for CHAR_BIT

// positive numbits -> right rotate, negative numbits -> left rotate
#define ROTATE(type, var, numbits) ((numbits) >= 0 ? \
                                    (var) >> (numbits) | (var) << (CHAR_BIT * sizeof(type) - (numbits)) : \
                                    (var) << -(numbits) | (var) >> (CHAR_BIT * sizeof(type) + (numbits)))

As sizeof() returns sizes as multiples of the size of char ( sizeof(char) == 1 ), and CHAR_BIT indicates the number of bits in a char (which, while usually 8, won't necessarily be), CHAR_BIT * sizeof(x) will give you the size of x in bits.

Answer 4

This is called a circular shift. There are intel x86 assembly instructions to do this but unless performance is REALLY REALLY A HUGE ISSUE you're better off using something like this:

int i = 0x42;
int by = 13;
int shifted = i << by | i >> ((sizeof(int) * 8) - by);

If you find yourself really needing the performance, you can use inline assembly to use the instructions directly (probably. I've never needed it badly enough to try).

It's also important to note that if you're going to be shifting by more places than the size of your data type, you need additional checks to make sure you're not overshifting. Using by = 48 would probably result in shifted receiving a value of 0, though this behavior may be platform specific (ie something to avoid like the plague) because if I recall correctly, some platforms perform this masking automatically and others do not.