Thread: bit shifting uint8_t

Is uint8_t a type char?

Most likely it's an unsigned char.

It looks like the OP has already figured this out, however:

First I had the problem of outputting it:

Code:

uint8_t var = 4;
cout << var << endl;

would output a box. however the workaround is using:

Code:

cout << (int)var << endl;

As for this:

But what I want to do is to shift the bits and the values do not make sense at all! Any ideas?

If you're still casting the value to an int before you print it, and you do the shifting on a separate line to avoid cout's overloaded <<, then the problem must be with the shifting statement itself. Post the statement.

Are you casting to int when you shift it?

Code:

uint8_t x = 40;
x = (int)x >> 2;
cout << (int)x << endl;

Right-shifting signed numbers, such as ints, doesn't work. (I think; it may be left-shifting that doesn't work. Anyway, just don't cast to a signed type like int and you should be okay.)

[edit] Found it: right-shifting negative signed numbers causes ones to appear rather than zeros (from http://cplus.about.com/od/advancedtu.../aa042203h.htm):

What does this have to do with right shifts? [...] With a signed number, the sign bit is replicated and shifted from the left to replace bits. For positive signed numbers, the sign bit is zero, so zeros are shifted in. For negative signed numbers, the sign bit is one, so ones are shifted in.

[/edit]

All things considered, something like this should work:

Code:

uint8_t x = 100;
x >>= 3;
x <<= 2;
cout << (int)x << endl;

Originally Posted by dwks

[edit] Found it: right-shifting negative signed numbers causes ones to appear rather than zeros (from http://cplus.about.com/od/advancedtu.../aa042203h.htm):
[/edit]

Correction:

The value of E1 >> E2 is E1 rightshifted E2 bit positions. If E1 has an unsigned type or if E1 has a signed type and a nonnegative value, the value of the result is the integral part of the quotient of E1 divided by the quantity 2 raised to the power E2. If E1 has a signed type and a negative value, the resulting value is implementation defined.

One of the options, of course, is just as you say.

I didn't believe him, and set out to write an example to prove him wrong... ^_^. (I learned something, I guess.) Something from my assembly knowledge was trying to say I would be wrong...
Personally, I think bit shifting on something with a sign is bound to get you into trouble... it doesn't make much sense.

I have this variable that has the uint8_t type (and yes I have to use this one for this project).

What's wrong with the (u)intX_t types? There are times when you need a variable that holds a set amount - I think those types fit the bill nicely.