Bitwise Operator.txt

----------
20191112

Bitwise and shift operators
https://docs.microsoft.com/zh-tw/dotnet/csharp/language-reference/operators/bitwise-and-shift-operators


本文內容
位元補充運算子 ~
左移運算子 <<
右移運算子 >>
邏輯 AND 運算子 &
邏輯互斥 OR 運算子 ^
邏輯 OR 運算子 |
複合指派
運算子優先順序
移位運算子的移位計數
列舉邏輯運算子
運算子是否可多載
C# 語言規格
請參閱
The following operators perform bitwise or shift operations with operands of the integral numeric types or the char type:
Unary ~ (bitwise complement) operator
Binary << (left shift) and >> (right shift) shift operators
Binary & (logical AND), | (logical OR), and ^ (logical exclusive OR) operators
Those operators are defined for the int, uint, long, and ulong types. When both operands are of other integral types (sbyte, byte, short, ushort, or char), their values are converted to the int type, which is also the result type of an operation. When operands are of different integral types, their values are converted to the closest containing integral type. For more information, see the Numeric promotions section of the C# language specification.
The &, |, and ^ operators are also defined for operands of the bool type. For more information, see Boolean logical operators.
Bitwise and shift operations never cause overflow and produce the same results in checked and unchecked contexts.
Bitwise complement operator ~

The ~ operator produces a bitwise complement of its operand by reversing each bit:
~ 為補數運算子, 運算結果會將每一個 bit 反轉: 1轉為0, 或 0轉為1
C#

複製

執行
uint a = 0b_0000_1111_0000_1111_0000_1111_0000_1100;
uint b = ~a;
Console.WriteLine(Convert.ToString(b, toBase: 2));
// Output:
// 11110000111100001111000011110011

You can also use the ~ symbol to declare finalizers. For more information, see Finalizers.
物件 class 的 finalizers 也是用  ~ 符號.


Left-shift operator <<
左移運算子

The << operator shifts its left-hand operand left by the number of bits defined by its right-hand operand.
The left-shift operation discards the high-order bits that are outside the range of the result type and sets the low-order empty bit positions to zero, as the following example shows:
<< 左移運算子 運算結果為: 將每一個bit位置往左移到高位位元, 並將空出來的低位元補0.

C#

複製

執行
uint x = 0b_1100_1001_0000_0000_0000_0000_0001_0001;
Console.WriteLine($"Before: {Convert.ToString(x, toBase: 2)}");

uint y = x << 4;
Console.WriteLine($"After:  {Convert.ToString(y, toBase: 2)}");
// Output:
// Before: 11001001000000000000000000010001
// After:  10010000000000000000000100010000


Because the shift operators are defined only for the int, uint, long, and ulong types, the result of an operation always contains at least 32 bits. If the left-hand operand is of another integral type (sbyte, byte, short, ushort, or char), its value is converted to the int type, as the following example shows:
由於移位運算子僅針對 int、uint、long 和 ulong 型別進行定義，所以作業的結果一律會包含至少 32 個位元。 左邊運算元是另一個整數型別 (sbyte、byte、short、ushort 或 char)，其值會轉換成 int 型別，如下列範例所示：

C#

複製

執行
byte a = 0b_1111_0001;

var b = a << 8;
Console.WriteLine(b.GetType());
Console.WriteLine($"Shifted byte: {Convert.ToString(b, toBase: 2)}");
// Output:
// System.Int32
// Shifted byte: 1111000100000000

For information about how the right-hand operand of the << operator defines the shift count, see the Shift count of the shift operators section.


Right-shift operator >>
右移運算子 >>

The >> operator shifts its left-hand operand right by the number of bits defined by its right-hand operand.
The right-shift operation discards the low-order bits, as the following example shows:
右移作業會捨棄低位位元

C#

複製

執行
uint x = 0b_1001;
Console.WriteLine($"Before: {Convert.ToString(x, toBase: 2), 4}");

uint y = x >> 2;
Console.WriteLine($"After:  {Convert.ToString(y, toBase: 2), 4}");
// Output:
// Before: 1001
// After:    10
The high-order empty bit positions are set based on the type of the left-hand operand as follows:
會根據左邊運算元的類型來設定高位空位元位置，如下所示

If the left-hand operand is of type int or long, the right-shift operator performs an arithmetic shift: the value of the most significant bit (the sign bit) of the left-hand operand is propagated to the high-order empty bit positions. That is, the high-order empty bit positions are set to zero if the left-hand operand is non-negative and set to one if it's negative.
如果左運算元的類型是 int 或 long，則右移運算子會執行算術移位：左側運算元的最高有效位（正負號位）值會傳播至高序位空白位位置。 也就是說，若左邊運算元不是負值且在為負值時被設定為一，則高位空位元位置會被設定為零。

C#

複製

執行
int a = int.MinValue;
Console.WriteLine($"Before: {Convert.ToString(a, toBase: 2)}");

int b = a >> 3;
Console.WriteLine($"After:  {Convert.ToString(b, toBase: 2)}");
// Output:
// Before: 10000000000000000000000000000000
// After:  11110000000000000000000000000000


If the left-hand operand is of type uint or ulong, the right-shift operator performs a logical shift: the high-order empty bit positions are always set to zero.
如果左運算元的類型是 uint 或 ulong，則右移運算子會執行邏輯移位：高序位空白位位置一律會設定為零。
C#

複製

執行
uint c = 0b_1000_0000_0000_0000_0000_0000_0000_0000;
Console.WriteLine($"Before: {Convert.ToString(c, toBase: 2), 32}");

uint d = c >> 3;
Console.WriteLine($"After:  {Convert.ToString(d, toBase: 2), 32}");
// Output:
// Before: 10000000000000000000000000000000
// After:     10000000000000000000000000000
For information about how the right-hand operand of the >> operator defines the shift count, see the Shift count of the shift operators section.
Logical AND operator &

The & operator computes the bitwise logical AND of its operands:
& 運算子會計算其運算元的位元邏輯 AND

C#

複製

執行
uint a = 0b_1111_1000;
uint b = 0b_1001_1101;
uint c = a & b;
Console.WriteLine(Convert.ToString(c, toBase: 2));
// Output:
// 10011000
& 常用來做 mask 運算

For bool operands, the & operator computes the logical AND of its operands. The unary & operator is the address-of operator.


Logical exclusive OR operator ^

The ^ operator computes the bitwise logical exclusive OR, also known as the bitwise logical XOR, of its operands:
C#

複製

執行
uint a = 0b_1111_1000;
uint b = 0b_0001_1100;
uint c = a ^ b;
Console.WriteLine(Convert.ToString(c, toBase: 2));
// Output:
// 11100100
For bool operands, the ^ operator computes the logical exclusive OR of its operands.
Logical OR operator |

The | operator computes the bitwise logical OR of its operands:
C#

複製

執行
uint a = 0b_1010_0000;
uint b = 0b_1001_0001;
uint c = a | b;
Console.WriteLine(Convert.ToString(c, toBase: 2));
// Output:
// 10110001
For bool operands, the | operator computes the logical OR of its operands.
Compound assignment

For a binary operator op, a compound assignment expression of the form
C#

複製
x op= y
is equivalent to
C#

複製
x = x op y
except that x is only evaluated once.
The following example demonstrates the usage of compound assignment with bitwise and shift operators:
C#

複製

執行
uint a = 0b_1111_1000;
a &= 0b_1001_1101;
Display(a);  // output: 10011000

a |= 0b_0011_0001;
Display(a);  // output: 10111001

a ^= 0b_1000_0000;
Display(a);  // output:   111001

a <<= 2;
Display(a);  // output: 11100100

a >>= 4;
Display(a);  // output:     1110

void Display(uint x) => Console.WriteLine($"{Convert.ToString(x, toBase: 2), 8}");
Because of numeric promotions, the result of the op operation might be not implicitly convertible to the type T of x. In such a case, if op is a predefined operator and the result of the operation is explicitly convertible to the type T of x, a compound assignment expression of the form x op= y is equivalent to x = (T)(x op y), except that x is only evaluated once. The following example demonstrates that behavior:
C#

複製

執行
byte x = 0b_1111_0001;

int b = x << 8;
Console.WriteLine($"{Convert.ToString(b, toBase: 2)}");  // output: 1111000100000000

x <<= 8;
Console.WriteLine(x);  // output: 0
Operator precedence

The following list orders bitwise and shift operators starting from the highest precedence to the lowest:
Bitwise complement operator ~
Shift operators << and >>
Logical AND operator &
Logical exclusive OR operator ^
Logical OR operator |
Use parentheses, (), to change the order of evaluation imposed by operator precedence:
C#

複製

執行
uint a = 0b_1101;
uint b = 0b_1001;
uint c = 0b_1010;

uint d1 = a | b & c;
Display(d1);  // output: 1101

uint d2 = (a | b) & c;
Display(d2);  // output: 1000

void Display(uint x) => Console.WriteLine($"{Convert.ToString(x, toBase: 2), 4}");
For the complete list of C# operators ordered by precedence level, see the Operator precedence section of the C# operators article.
Shift count of the shift operators

For the shift operators << and >>, the type of the right-hand operand must be int or a type that has a predefined implicit numeric conversion to int.
For the x << count and x >> count expressions, the actual shift count depends on the type of x as follows:
If the type of x is int or uint, the shift count is defined by the low-order five bits of the right-hand operand. That is, the shift count is computed from count & 0x1F (or count & 0b_1_1111).
If the type of x is long or ulong, the shift count is defined by the low-order six bits of the right-hand operand. That is, the shift count is computed from count & 0x3F (or count & 0b_11_1111).
The following example demonstrates that behavior:
C#

複製

執行
int count1 = 0b_0000_0001;
int count2 = 0b_1110_0001;

int a = 0b_0001;
Console.WriteLine($"{a} << {count1} is {a << count1}; {a} << {count2} is {a << count2}");
// Output:
// 1 << 1 is 2; 1 << 225 is 2

int b = 0b_0100;
Console.WriteLine($"{b} >> {count1} is {b >> count1}; {b} >> {count2} is {b >> count2}");
// Output:
// 4 >> 1 is 2; 4 >> 225 is 2
Enumeration logical operators

The ~, &, |, and ^ operators are also supported by any enumeration type. For operands of the same enumeration type, a logical operation is performed on the corresponding values of the underlying integral type. For example, for any x and y of an enumeration type T with an underlying type U, the x & y expression produces the same result as the (T)((U)x & (U)y) expression.
You typically use bitwise logical operators with an enumeration type which is defined with the Flags attribute. For more information, see the Enumeration types as bit flags section of the Enumeration types article.
Operator overloadability

A user-defined type can overload the ~, <<, >>, &, |, and ^ operators. When a binary operator is overloaded, the corresponding compound assignment operator is also implicitly overloaded. A user-defined type cannot explicitly overload a compound assignment operator.
If a user-defined type T overloads the << or >> operator, the type of the left-hand operand must be T and the type of the right-hand operand must be int.
C# language specification

For more information, see the following sections of the C# language specification:
Bitwise complement operator
Shift operators
Logical operators
Compound assignment
Numeric promotions




----------
AND &

static void AND()
{
	// If the mask value is 1, and the value is 1, it sets it to 1
	// If the mask value is 1, and the value is 0, it keeps that 0
	// If the mask value is 0, the value is set to 0 regardless
	// 42   = 0010 1010
	// 36   = 0010 0100
	//
	// val  = 0010 0000 = 32
	int val = 42 & 36;
	WL("{0}",val);
}

static void OR()
{
	// If the mask value is 0, the original is returned
	// If the mask value is 1, 1 is returned (i.e. true || false == true)
	// 42   = 0010 1010
	// 36   = 0010 0100
	//
	// val  = 0010 1110 = 46
	int val = 42 | 36;
	WL("{0}",val);
}

----------
XOR

1.	XOR ユ传 
2.	ヴ计 XOR セō穦眔 0 
3.	ヴ计 XOR 0 穦眔セō 
4.	ヴ计XOR 1 穦眔セō干计
static void XOR()
{
	// Sets the bit only if 1 of the values is true, not both
	// 42   = 0010 1010
	// 36   = 0010 0100
	//
	// val  = 0000 1110 = 14
	int val = 42 ^ 36;
	WL("{0}",val);
}


static void OREQUALS()
{
	// Shorthand or alternative syntax for the OR mask,
	// saves doing "val = val | 36".
	int val = 42;
	val |= 36;
	WL("{0}",val);
}


static void ANDEQUALS()
{
	// Shorthand or alternative syntax for the AND mask
	int val = 42;
	val &= 36;
	WL("{0}",val);
}

static void XOREQUALS()
{
	// Shorthand or alternative syntax for the XOR mask
	int val = 42;
	val ^= 36;
	WL("{0}",val);
}

static void NOT()
{
	// 42   = 0000 0000 0010 1010
	//
	// Result:
	// -43  = 1111 1111 1101 0101
	//
	// Inverts the bits of 42, see the other article
	// of how this works with 2s complement (you basically
	// invert the bits and add 1)
	int val = 42;
	val = ~42;
	WL("{0}",val);
}


// The Flags attribute is used for parsing of the enum and its string representation,
// and is not actually necessary for the bit operations
[Flags]
enum Rights
{
	None = 0,       // 0000 0000
	ReadFile = 1,   // 0000 0001
	ModifyFile = 2, // 0000 0010
	WriteFile = 4,  // 0000 0100
	ReadDir = 8,    // 0000 1000
	All = ReadFile | ModifyFile | WriteFile | ReadDir
}

static void FLAGS()
{
	// Using OR - adding values
	// rights  = 0000 0001 (ReadFile)
	// a       = 0000 0010 (ModifyFile)
	// b       = 0000 0100 (WriteFile)
	// rights  = 0000 0111 = 7
	Rights rights = Rights.ReadFile;
	rights |= Rights.ModifyFile;
	rights |= Rights.WriteFile;
	WL("|= {0}",rights);
	
	// Using AND
	// rights  = 0000 0111
	// a       = 0000 0010 (ModifyFile)
	// rights  = 0000 0010 = 2
	rights &= Rights.ModifyFile;
	WL("&= {0}",rights);
	
	// Using XOR - removing a single value
	// rights  = 0000 0111
	// a       = 0000 0010 (ModifyFile)
	// rights  = 0000 0101 = 5
	rights = InitRights();
	rights ^= Rights.ModifyFile;
	
	WL("^= {0}",rights);
	// Using ~ - removing multiple flags
	// rights  = 0011 1111
	// a       = 1111 1001 ~(ModifyFile | WriteFile)
	rights = Rights.All;
	rights &= ~(Rights.ModifyFile | Rights.WriteFile);
	WL("~ {0}",rights);
	
	// Testing if it contains a value
	// rights  = 0000 0110
	// test    = 0000 1000
	// displays None
	rights = Rights.WriteFile | Rights.ModifyFile;
	Rights test = rights & Rights.ReadDir;
	WL("Contains Rights.ReadDir: {0}",test == Rights.ReadDir);
	
	// Testing if it contains value 1 or value 2
	// rights  = 0000 1110
	// test    = 0000 0000
	// displays None
	rights = InitRights();
	if ((rights & Rights.ReadFile) == Rights.ReadFile)
	WL("If test: contains ReadFile");
	if ((rights & Rights.ModifyFile) == Rights.ModifyFile)
	WL("If test: contains ModifyFile");
}

static Rights InitRights()
{
	return Rights.ReadFile | Rights.ModifyFile | Rights.WriteFile;
}

static void SHIFTLEFT()
{
	// 42   = 0010 1010
	// << 2 = 1010 1000 = 168
	int val = 42;
	val = val << 2;
	WL("{0}",val);
	
	// Pushing beyond 8 bits
	// 42   = 0000 0000 0010 1010
	// << 4 = 0000 0010 1010 0000 = 672 (512 + 128 + 32)
	val = 42;
	val = val << 4;
	WL("{0}",val);
}

static void SHIFTRIGHT()
{
	// 42   = 0010 1010
	// >> 2 = 0000 1010 = 10)
	int val = 42;
	val = val >> 2;
	WL("{0}",val);
	
	//  42   = 0010 1010
	// inverted using 1s complement
	//  -42  = 1101 0101
	//  -42  = 1101 0110 (2s complement: add 1)
	//  105  = 0110 1001
	// -105  = 1001 0111
	//  120,000 = 0000 0000 0000 0001 1101 0100 1100 0000
	// -120,000 = 1111 1111 1111 1110 0010 1011 0011 1111 (1s)
	//            1111 1111 1111 1110 0010 1011 0100 0000 (2s - added 1)
	// 42      = 0010 1010
	// -42     = 1101 0110
	// -42 >>2 = 0011 0101
	// -42 >>2 = 1111 0101 (it pads the zeros to the left with 1s)
	val = -42;
	val = val >> 2;
	WL("{0}",val);
}

static void NEGATIVESHIFT()
{
	// Using 256 as 42 doesn't have enough bits (it right shifts to 0)
	//
	// 256   = 0000 0001 0000 0000
	// -6    = 0000 0000 1111 1010 With shifting, this is promoted to an int, using the last 5 bits
	//       = 0000 0000 0001 1010 (2 + 8 + 16 = 26)
	//       = 0000 0000 0000 0000 (Zero as its shifting 26 bits to the right)
	int val = 256 >> -6;
	WL("{0}",val);
}