C language bitwise (1)

Bit operation application tips

Use or
To reverse and exchange, you can easily use an exception or

Shift operation
Key Aspect 1: They are binary operators, both of which are integers, and the result is also an integer.
2 "<" Left shift: Fill 0 on the right blank bit. The left bit will be squeezed out from the header, and its value is equal to 2.
3 ">" right shift: The right bit is squeezed out. For the vacant positions removed from the left, if it is a positive number, the vacant space is supplemented with 0. If it is a negative number, it may be supplemented with 0 or 1, depending on the computer system used.
4 ">>>" operator, the right bit is squeezed out, and 0 is added for the left removed space.
Application of bitwise operators (source operand s mask)
(1) bitwise AND --&
1. Reset the special location (0 for a specific position in the mask, 1 for other bits, S = S & Mask)
2. Locate a specified position in a specified number (1 in mask, 0 for other bits, S = S & Mask)
(2) bitwise OR -- |
It is often used to set the source operand to some positions of 1, and the other BITs remain unchanged. (In mask, the specific position is 1, and the other bit is 0 s = S | mask)
(3) bitwise OR -- ^
1. Reverse the value of the specific location (1 in a specific position in mask and 0 s = s ^ mask in other bits)
2. If the third variable is not introduced, the values of the two variables are exchanged (set a = A1, B = B1)
Status after target operation
A = A1 ^ B1 A = a ^ B a = A1 ^ B1, B = b1
B = A1 ^ B1 ^ B1 B = a ^ B a = A1 ^ B1, B = A1
A = b1 ^ A1 ^ A1 A = a ^ B a = b1, B = A1
Binary complement calculation formula:
-X = ~ X + 1 = ~ X-1)
~ X =-X-1
-(~ X) = x + 1
~ (-X) = X-1
X + y = x -~ Y-1 = (X | Y) + (X & Y)
X-y = x ++ ~ Y + 1 = (X | ~ Y )-(~ X & Y)
X ^ y = (X | Y)-(X & Y)
X | Y = (X &~ Y) + Y
X & Y = (~ X | Y )-~ X
X = Y :~ (X-y | Y-x)
X! = Y: x-y | Y-x
X <Y: (x-y) ^ (x ^ y) & (x-y) ^ X ))
X <= Y: (x | ~ Y) & (x ^ y) | ~ (Y-x ))
X <Y :(~ X & Y) | ((~ X | Y) & (x-y) // comparison of unsigned X and Y
X <= Y :(~ X | Y) & (x ^ y) | ~ (Y-x) // unsigned x, y comparison
Application Example
(1) judge whether int variable A is an odd or even number.
A & 1 = 0 even
A & 1 = 1 odd
(2) Take the K-bit (k =, 2…) of int-type variable ...... Sizeof (INT), that is, a> K & 1
(3) Clear the K bit of int variable A by 0, that is, a = &~ (1 <K)
(4) Place the K position of int type variable A 1, that is, a = A | (1 <K)
(5) int type variable loops are shifted K times left, that is, a = A <k | A> 16-k (set sizeof (INT) = 16)
(6) int type variable A shifts K times to the right, that is, a = A> K | A <16-k (set sizeof (INT) = 16)
(7) Average integer
If two integers x and y are used to calculate the average value (x + y)/2, the overflow will occur, because X + Y may be greater than int_max, however, we know that their average values will certainly not overflow. We use the following Algorithm :
Int average (int x, int y) // returns the average value of X and Y.
{
Return (X & Y) + (x ^ y)> 1 );
}
(8) judge whether an integer is the power of 2. For a number x> = 0, determine whether it is the power of 2.
Boolean power2 (int x)
{
Return (X & (x-1) = 0) & (X! = 0 );
}
(9) two integers are not exchanged using temp.
Void swap (int x, int y)
{
X ^ = y;
Y ^ = X;
X ^ = y;
}
(10) Calculate the absolute value
Int ABS (int x)
{
Int y;
Y = x> 31;
Return (x ^ y)-y; // or: (x + y) ^ y
}
(11) modulo operation into bitwise operation (without Overflow)
A % (2 ^ N) is equivalent to a & (2 ^ n-1)
(12) multiplication is converted into bitwise operations (without Overflow)
A * (2 ^ N) is equivalent to a <n
(13) Division operations are converted into bitwise operations (without Overflow)
A/(2 ^ N) is equivalent to a> N
For example: 12/8 = 12> 3
(14) A % 2 is equivalent to a & 1
(15) if (x = A) x = B;
Else x =;
It is equivalent to X = a ^ B ^ X;

(16) The opposite number of X is expressed (~ X + 1)

# Include <stdio. h>
// Set the Y-th of X to 1.
# Define setbit (x, y) (x) | = (1 <(Y-1 ))
// Obtain the Y-th value of X.
# Define bitget (number, POS) (number) >>( pos-1) & 1)
// Print the value of X
# Define print (x) printf ("% d \ n", X)
// Round the integer (4 bytes) to the right to move K digits
# Define rot (A, K) (a) <(k) | (a)> (32-k ))
// Determine whether a is a power of 2
# Define pow2 (A) (a) & (A-1) = 0) & (! = 0 ))
# Define oppx (x )(~ (X) + 1)
// Returns the average values of X and Y.
Int average (int x, int y)
{
Return (X & Y) + (x ^ y)> 1 );
}
// Determine whether a is a power of 2
Bool power2 (int x)
{
Return (X & (x-1) = 0) & (X! = 0 );
}
// Swap X with Y
Void swap (Int & X, Int & Y)
{
X ^ = y;
Y ^ = X;
X ^ = y;
}
Int main ()
{
Int A = 0x000d;
Print ();
Int B = bitget (A, 2 );
Print (B );
Setbit (A, 2 );
Print ();
Print (bitget (A, 2 ));
Int c = rot (A, 33 );
Print (C );
Print (bitget (C, 5 ));
Printf ("8 + 5 = % d \ n", average (8,692 ));
Int I;
For (I = 0; I <1000; I ++)
{
If (pow2 (I) // call power2 (I)
{
Printf ("%-5d", I );
}
}
Printf ("\ n ");
Int x = 10, y = 90;
Swap (x, y );
Print (X );
Print (y );
Print (oppx (-705 ));
Return 0;
}

From: http://blog.163.com/huang_minjian/blog/static/18207654920113139446382/