C# 运算符

提示

1. 赋值和算术运算符：C#中的赋值运算符用于向变量赋值，而算术运算符用于执行基本的数学运算，如加法、减法、乘法和除法。
2. 关系和逻辑运算符：关系运算符用于比较两个操作数并返回布尔值，而逻辑运算符用于执行逻辑运算（如AND、OR），主要用于决策和循环控制。
3. 一元、三元和位运算符：一元运算符对单个操作数进行操作，三元运算符是简化的if-then-else语句，位运算符用于执行位级操作，如位与、位或、位移等。

运算符是用于对操作数进行操作的符号。操作数可以是变量和/或常量。

例如，在 2 + 3 中，+ 是用来执行加法操作的运算符，而 2 和 3 是操作数。

运算符用于在程序中操纵变量和值。C# 支持多种基于它们执行操作类型的分类运算符。

1. 基本赋值运算符

基本赋值运算符（=）用于向变量赋值。例如，

double x;
x = 50.05;

这里，50.05 被赋给了 x。

示例 1：基本赋值运算符

using System;

namespace Operator
{
	class AssignmentOperator
	{
		public static void Main(string[] args)
		{
			int firstNumber, secondNumber;
			// 将常量赋值给变量
			firstNumber = 10;
			Console.WriteLine("First Number = {0}", firstNumber);

			// 将一个变量赋值给另一个变量
			secondNumber = firstNumber;
			Console.WriteLine("Second Number = {0}", secondNumber);
		}
	}
}

当我们运行程序时，输出将会是：

First Number = 10
Second Number = 10

这是一个展示了赋值运算符使用的简单例子。

你可能已经注意到了示例中 { } 的使用。我们将在 字符串格式化 中讨论它们。现在，只需记住 {0} 会被字符串后面的第一个变量替换，{1} 会被第二个变量替换，依此类推。

2. 算术运算符

算术运算符用于执行加法、减法、乘法、除法等算术运算。

例如，

int x = 5;
int y = 10;
int z = x + y; // z = 15

C# 算术运算符

运算符	运算符名称	示例
+	加法运算符	6 + 3 计算结果为 9
-	减法运算符	10 - 6 计算结果为 4
_	乘法运算符	4 _ 2 计算结果为 8
/	除法运算符	10 / 5 计算结果为 2
%	取模运算符（余数）	16 % 3 计算结果为 1

示例 2：算术运算符

using System;

namespace Operator
{
	class ArithmeticOperator
	{
		public static void Main(string[] args)
		{
			double firstNumber = 14.40, secondNumber = 4.60, result;
			int num1 = 26, num2 = 4, rem;

			// 加法运算符
			result = firstNumber + secondNumber;
			Console.WriteLine("{0} + {1} = {2}", firstNumber, secondNumber, result);

			// 减法运算符
			result = firstNumber - secondNumber;
			Console.WriteLine("{0} - {1} = {2}", firstNumber, secondNumber, result);

			// 乘法运算符
			result = firstNumber * secondNumber;
			Console.WriteLine("{0} * {1} = {2}", firstNumber, secondNumber, result);

			// 除法运算符
			result = firstNumber / secondNumber;
			Console.WriteLine("{0} / {1} = {2}", firstNumber, secondNumber, result);

			// 取模运算符
			rem = num1 % num2;
			Console.WriteLine("{0} % {1} = {2}", num1, num2, rem);
		}
	}
}

当我们运行程序时，输出将是：

14.4 + 4.6 = 19
14.4 - 4.6 = 9.8
14.4 * 4.6 = 66.24
14.4 / 4.6 = 3.1304347826087
26 % 4 = 2

上面的例子执行了算术运算。在语句中可以用常量替换变量。例如，

result = 4.5 + 2.7 ; // result 将保存 7.2
result = firstNumber - 3.2; // result 将保存 11.2

3. 关系运算符

关系运算符用于检查两个操作数之间的关系。如果关系为真，则结果为 true，否则将导致 false。

关系运算符在决策制定和循环中使用。

C# 关系运算符

运算符	运算符名称	示例
==	等于	6 == 4 计算结果为 false
>	大于	3 > -1 计算结果为 true
<	小于	5 < 3 计算结果为 false
>=	大于或等于	4 >= 4 计算结果为 true
<=	小于或等于	5 <= 3 计算结果为 false
!=	不等于	10 != 2 计算结果为 true

示例 3：关系运算符

using System;

namespace Operator
{
	class RelationalOperator
	{
		public static void Main(string[] args)
		{
			bool result;
			int firstNumber = 10, secondNumber = 20;

			result = (firstNumber==secondNumber);
			Console.WriteLine("{0} == {1} 返回 {2}",firstNumber, secondNumber, result);

			result = (firstNumber > secondNumber);
			Console.WriteLine("{0} > {1} 返回 {2}",firstNumber, secondNumber, result);

			result = (firstNumber < secondNumber);
			Console.WriteLine("{0} < {1} 返回 {2}",firstNumber, secondNumber, result);

			result = (firstNumber >= secondNumber);
			Console.WriteLine("{0} >= {1} 返回 {2}",firstNumber, secondNumber, result);

			result = (firstNumber <= secondNumber);
			Console.WriteLine("{0} <= {1} 返回 {2}",firstNumber, secondNumber, result);

			result = (firstNumber != secondNumber);
			Console.WriteLine("{0} != {1} 返回 {2}",firstNumber, secondNumber, result);
		}
	}
}

当我们运行程序时，输出将是：

10 == 20 返回 False
10 > 20 返回 False
10 < 20 返回 True
10 >= 20 返回 False
10 <= 20 返回 True
10 != 20 返回 True

4. 逻辑运算符

逻辑运算符用于执行如 and、or 等逻辑运算。逻辑运算符对布尔表达式（true 和 false）操作并返回布尔值。逻辑运算符在决策制定和循环中使用。

以下是逻辑 AND 和 OR 运算符计算结果的方式。

C# 逻辑运算符

操作数 1	操作数 2	OR ( | | )	AND (&&)
true	true	true	true
true	false	true	false
false	true	true	false
false	false	false	false

简单来说，这个表格可以总结为：

• 如果一个操作数为真，则 OR 运算符将其计算为 true。
• 如果一个操作数为假，则 AND 运算符将其计算为 false。

示例 4：逻辑运算符

using System;

namespace Operator
{
	class LogicalOperator
	{
		public static void Main(string[] args)
		{
			bool result;
			int firstNumber = 10, secondNumber = 20;
			
			// OR operator
			result = (firstNumber == secondNumber) || (firstNumber > 5);
			Console.WriteLine(result);

			// AND operator
			result = (firstNumber == secondNumber) && (firstNumber > 5);
			Console.WriteLine(result);
		}
	}
}

```

当我们运行程序时，输出将会是：

```csharp
True
False

5. 一元运算符

与其他运算符不同，一元运算符只操作一个操作数。

C# 一元运算符

运算符	运算符名称	描述
+	一元正号	保持操作数的符号不变
-	一元负号	反转操作数的符号
++	自增	将值增加 1
--	自减	将值减少 1
!	逻辑取反（Not）	反转布尔值

示例 5：一元运算符

using System;

namespace Operator
{
	class UnaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10, result;
			bool flag = true;

			result = +number;
			Console.WriteLine("+number = " + result);

			result = -number;
			Console.WriteLine("-number = " + result);

			result = ++number;
			Console.WriteLine("++number = " + result);

			result = --number;
			Console.WriteLine("--number = " + result);

			Console.WriteLine("!flag = " + (!flag));
		}
	}
}

当我们运行程序时，输出将会是：

+number = 10
-number = -10
++number = 11
--number = 10
!flag = False

自增 (++) 和自减 (--) 运算符可以用作前缀和后缀。如果用作前缀，变量的值变化会在同一行看到；如果用作后缀，变量的值变化会在下一行看到。以下示例将使这一点更加清晰。

示例 6：C# 中的前自增和后自增运算符

using System;

namespace Operator
{
	class UnaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;

			Console.WriteLine((number++));
			Console.WriteLine((number));

			Console.WriteLine((++number));
			Console.WriteLine((number));
		}
	}
}

当我们运行程序时，输出将会是：

10
11
12
12

我们可以看到作为前缀和后缀使用 ++ 的效果。当 ++ 在操作数之后使用时，首先对值进行评估，然后增加 1。因此语句

Console.WriteLine((number++));

打印的是 10 而不是 11。打印值后，number 的值增加了 1。

当 ++ 作为前缀使用时，过程则相反。打印之前先增加值。因此语句

Console.WriteLine((++number));

打印的是 12。

自减运算符 (--) 也是如此。

6. 三元运算符

三元运算符 ? : 操作三个操作数。它是 if-then-else 语句的简写形式。三元运算符的使用方式如下：

三元运算符的工作原理如下：

- 如果 `Condition` 表达的表达式为 `true`，则 `Expression1` 的结果赋给变量。
- 如果为 `false`，则 `Expression2` 的结果赋给变量。

### 示例 7：三元运算符

```csharp
using System;

namespace Operator
{
	class TernaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;
			string result;

			result = (number % 2 == 0)? "Even Number" : "Odd Number";
			Console.WriteLine("{0} 是 {1}", number, result);
		}
	}
}

当我们运行程序时，输出将是：

10 是 Even Number

要了解更多，请访问 C# 三元运算符。

7. 位运算和位移运算符

位运算和位移运算符用于执行位操作。

C# 位运算和位移运算符

运算符	运算符名称
~	位补运算
&	位与运算
|	位或运算
^	位异或运算
<<	位左移
>>	位右移

示例 8：位运算和位移运算符

using System;

namespace Operator
{
	class BitOperator
	{
		public static void Main(string[] args)
		{
			int firstNumber = 10;
			int secondNumber = 20;
			int result;

			result = ~firstNumber;
			Console.WriteLine("~{0} = {1}", firstNumber, result);

			result = firstNumber & secondNumber;
			Console.WriteLine("{0} & {1} = {2}", firstNumber, secondNumber, result);

			result = firstNumber | secondNumber;
			Console.WriteLine("{0} | {1} = {2}", firstNumber, secondNumber, result);

			result = firstNumber ^ secondNumber;
			Console.WriteLine("{0} ^ {1} = {2}", firstNumber, secondNumber, result);

			result = firstNumber << 2;
			Console.WriteLine("{0} << 2 = {1}", firstNumber, result);

			result = firstNumber >> 2;
			Console.WriteLine("{0} >> 2 = {1}", firstNumber, result);
		}
	}
}

当我们运行程序时，输出将是：

~10 = -11
10 & 20 = 0
10 | 20 = 30
10 ^ 20 = 30
10 << 2 = 40
10 >> 2 = 2

要了解更多，请访问 C# 位运算和位移运算符。

8. 复合赋值运算符

C# 复合赋值运算符

运算符	运算符名称	示例	等价于
+=	加法赋值	x += 5	x = x + 5
-=	减法赋值	x -= 5	x = x - 5
\_=	乘法赋值	x _= 5	x = x * 5
/=	除法赋值	x /= 5	x = x / 5
%=	模运算赋值	x %= 5	x = x % 5
&=	位与赋值	x &= 5	x = x & 5
|=	位或赋值	x | = 5	x = x | 5
^=	位异或赋值	x ^= 5	x = x ^ 5
<<=	左移赋值	x <<= 5	x = x << 5
>>=	右移赋值	x >>= 5	x = x >> 5
=>	Lambda 运算符	x => x*x	返回 x\*x

示例 9：复合赋值运算符

```csharp
using System;

namespace Operator
{
	class BitOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;

			number += 5;
			Console.WriteLine(number);

			number -= 3;
			Console.WriteLine(number);

			number *= 2;
			Console.WriteLine(number);

			number /= 3;
			Console.WriteLine(number);

			number %= 3;
			Console.WriteLine(number);

			number &= 10;
			Console.WriteLine(number);

			number |= 14;
			Console.WriteLine(number);

			number ^= 12;
			Console.WriteLine(number);

			number <<= 2;
			Console.WriteLine(number);

			number >>= 3;
			Console.WriteLine(number);
		}
	}
}

当我们运行程序时，输出将会是：

15
12
24
8
2
2
14
2
8
1

我们将在后续教程中讨论 Lambda 运算符。