bit-manipulation

i am reading a .cpp file containing a unsigned char variable, it's trying the bitwise left shift 16 bits, since an unsigned char is composed of 8 bits, left shift 16 bits will erase all the bits and fill it with eight 0s. unsigned char byte=0xff; byte << 16; When you shift a value, unsigned char x = ...; int y = x << 16; The type of x is promoted to int if unsigned char fits in an int (most systems), or to unsigned if unsigned char does not fit in an int (rare 1 ). As long as your int is 25 bits wide or wider, then no data will be discarded 2 . Note that this is completely unrelated to the

Consider: echo 50 >> 4; Output: 3 Why does it output 3? nevets1219 50 in binary is 11 0010 , shift right by 4 yields 11 which is equal to 3. See PHP documentation and Wikipedia . As documented on php.org , the >> operator is a bitwise shift operator which shifts bits to the right: $a >> $b - Shift the bits of $a $b steps to the right (each step means "divide by two") 50 in binary is 110010 , and the >> operator shifts those bits over 4 places in your example code. Although this happens in a single operation, you could think of it in multiple steps like this: Step 1 - 00011001 Step 2 - 00001100

Let i be a signed integer type. Consider i += (i&-i); i -= (i&-i); where initially i>0 . What do these do? Is there an equivalent code using arithmetic only? Is this dependent on a specific bit representation of negative integers? Source: setter's code of an online coding puzzle (w/o any explanation/comments). If i has unsigned type, the expressions are completely portable and well-defined. If i has signed type, it's not portable, since & is defined in terms of representations but unary - , += , and -= are defined in terms of values. If the next version of the C++ standard mandates twos

I know these warnings are probably pointless.. But anyway I could get rid of them? I got 7 of these warnings. Bitwise-or operator used on a sign-extended operand; consider casting to a smaller unsigned type first This has something to do with the OR operator | I highlighted what gives off the warnings. int result = (int)ror((uint)(v76 ^ (v75 | 0x862D63D3)), (uint)(BitConverter.ToInt32(v4, 72) ^ 0x22)); int v11 = (int)rol((uint)(int)((v8 & v10 | ~v10 & 0xEFCDAAC9) + v3[2] - 1126481991), 17); int v144 = (int)rol((uint)(int)((v141 & v143 | ~v143 & 0xEFCDAAC9) + v3[2] - 1126481991), 17); int v77 =

I have a UTC date time without the formatting stored in a uint64, ie: 20090520145024798 I need to get the hours, minutes, seconds and milliseconds out of this time. I can do this very easily by converting it to a string and using substring. However, this code needs to be very fast so I would like to avoid string manipulations. Is there faster way, perhaps using bit manipulation to do this? Oh by the way this needs to be done in C++ on Linux. uint64 u = 20090520145024798; unsigned long w = u % 1000000000; unsigned millisec = w % 1000; w /= 1000; unsigned sec = w % 100; w /= 100; unsigned min =

I was wondering how I could go about multiplying a series of binary bits using bitwise operators. However, I'm interested in doing this to find the a decimal fraction value for the binary value. Here's an example of what I'm trying to do: Given, say: 1010010, I want to use each individual bit so that it will be computed as: 1*(2^-1) + 0*(2^-2) + 1*(2^-3) + 0*(2^-4)..... Though I'm interested in doing this in ARM assembly, having an example in C/C++ will still help as well. I was thinking of performing a loop with a counter, where each time the loop iterates, a counter will increment, the value

Given a binary number, what is the fastest way of removing the lowest order bit? 01001001010 -> 01001001000 It would be used in code to iterate over the bits of a variable. Pseudo-code follows. while(bits != 0){ index = getIndexOfLowestOrderBit(bits); doSomething(index); removeLowestOrderBit(bits); } The possible languages I'm considering using are C and Java. Uh ... In your example, you already know the bit's index. Then it's easy: bits &= ~(1 << index); This will mask off the bit whose index is index , regardless of its position in the value (highest, lowest, or in-between). Come to think of