bit-shift

Could someone explain me why: x = x << 1; x = x >> 1; and: x = (x << 1) >> 1; produce different answers in C? x is a *uint8_t* type (unsigned 1-byte long integer). For example when I pass it 128 (10000000) in the first case it returns 0 (as expected most significant bit falls out) but in the second case it returns the original 128 . Why is that? I'd expect these expressions to be equivalent? This is due to integer promotions, both operands of the bit-wise shifts will be promoted to int in both cases. In the second case: x = (x << 1) >> 1; the result of x << 1 will be an int and therefore the

Can anyone explain why the following doesn't compile? byte b = 255 << 1 The error: Constant value '510' cannot be converted to a 'byte' I'm expecting the following in binary: 1111 1110 The type conversion has stumped me. Joey Numeric literals in C# are int , not byte (and the bit shift will be evaluated by the compiler, hence only the 510 remains). You are therefore trying to assign a value to a byte which does not fit. You can mask with 255: byte b = (255 << 1) & 0xFF to reduce the result to 8 bits again. Unlike Java, C# does not allow overflows to go by undetected. Basically you'd have two

I have a question. uint64_t var = 1; // this is 000000...00001 right? And in my code this works: var ^ (1 << 43) But how does it know 1 should be in 64 bits? Shouldn’t I write this instead? var ^ ( (uint64_t) 1 << 43 ) As you supposed, 1 is a plain signed int (which probably on your platform is 32 bit wide in 2's complement arithmetic), and so is 43, so by any chance 1<<43 results in an overflow: in facts, if both arguments are of type int operator rules dictate that the result will be an int as well. Still, in C signed integer overflow is undefined behavior, so in line of principle anything

I'm practising for the SCJP exam using cram notes from the Internet. According to my notes the >> operator is supposed to be signed right shift, with the sign bit being brought in from the left. While the left shift operator << is supposed to preserve the sign bit. Playing around however, I'm able to shift the sign with the << operator (f.e. Integer.MAX_VALUE << 1 evaluates to -2 , while I'm never able to shift the sign with the >> operator. I must be misunderstanding something here, but what? ">>" is signed because it keeps the sign. It uses the most left digit in binary representation of a

I must be absolutely crazy here, but gcc 4.7.3 on my machine is giving the most absurd result. Here is the exact code that I'm testing: #include <iostream> using namespace std; int main(){ unsigned int b = 100000; cout << (b>>b) << endl; b = b >> b; cout << b << endl; b >>= b; cout << b << endl; return 0; } Now, any number that's right shifted by itself should result in 0 ( n/(2^n) == 0 with integer divide , n>1 , and positive/unsigned ), but somehow here is my output: 100000 100000 100000 Am I crazy? What could possibly be going on? In C++ as in C, shifts are limited to the size (in bits) of

Consider the following snip of java code byte b=(byte) 0xf1; byte c=(byte)(b>>4); byte d=(byte) (b>>>4); output: c=0xff d=0xff expected output: c=0x0f how? as b in binary 1111 0001 after unsigned right shift 0000 1111 hence 0x0f but why is it 0xff how? The problem is that all arguments are first promoted to int before the shift operation takes place: byte b = (byte) 0xf1; b is signed, so its value is -15. byte c = (byte) (b >> 4); b is first sign-extended to the integer -15 = 0xfffffff1 , then shifted right to 0xffffffff and truncated to 0xff by the cast to byte . byte d = (byte) (b >>> 4); b

Okay, I tried looking up what >>, or shift means, but it's way over my head as this site explains it: http://www.janeg.ca/scjp/oper/shift.html So can someone explain it like they're talking to a kid? Computers are binary devices. Because of this, numbers are represented by a sequence of 1s and 0s. Bitshifting is simply moving those sequences of 1s and 0s left or right. So all the >> operator does is shift the bits towards the right one bit. Consider the number 101: // Assuming signed 8-bit integers 01100101 // How 101 is represented in binary 00110010 // After right shifting one bit, this