C# 运算符

总目录

前言

在C#中，运算符是用于执行特定操作的符号。它们可以用于处理变量、常量或其他表达式。C# 提供了丰富的运算符集合，用于执行各种操作，如算术运算、逻辑判断、位操作等。了解这些运算符及其使用方式对于编写高效且功能强大的C#程序至关重要。

一、算术运算符

算术运算符用于执行基本的数学运算，如加法、减法、乘法、除法和取模。

1. 算术运算符概览

2. 注意事项

• 溢出检查：算术运算可能溢出，可用checked检查溢出。
• + 加法运算符：用于两个字符串或字符串与数值类时，是拼接字符串
  • string s = “Hello” + “World”; // “HelloWorld”
  • string s = “Hello” + 1; // “Hello1”
• /除法运算符 ：运算结果取决于操作数的类型
  • 当两个操作数均为整数的时候，进行取商运算，结果为整数（舍弃小数部分）；
  • 当两边有一个为浮点型的时候，进行精确运算，结果为浮点数；
  • 用(double)7 / 2得3.5；避免除0错误（抛出DivideByZeroException）
• %取模运算符 ：用于获取除法运算的余数
  • 可用于判断奇偶、周期性操作
• ++自增/自减运算符：增量和减量运算符用于将变量的值增加或减少1。
  • 当自增/自减运算符在前（形如 ++a），则先自增，再赋值；
  • 当自增/自减运算符在后（形如 a++），则先赋值，再自增；
• char类型：在char类型参与到算术运算时，会自动转化为ascii码10进制的值参与运算

3. 示例

int a = 5;
int b = 2;

int sum = a + b;   // 7
int diff = a - b;  // 3
int product = a * b; // 10
int quotient = a / b; // 2
int remainder = a % b; // 1

Console.WriteLine($"Sum: {sum}, Diff: {diff}, Product: {product}, Quotient: {quotient}, Remainder: {remainder}");

	class Program
    {
        static void Main(string[] args)
        {
            int a = 1;
            int b;

            // a++ 先赋值再进行自增运算
            b = a++;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();//结果a=2,b=1

            // ++a 先进行自增运算再赋值
            a = 1; // 重新初始化 a
            b = ++a;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();//结果a=2,b=2

            // a-- 先赋值再进行自减运算
            a = 1;  // 重新初始化 a
            b= a--;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();//结果a=0,b=1

            // --a 先进行自减运算再赋值
            a = 1;  // 重新初始化 a
            b= --a;
            Console.WriteLine("a = {0}", a);
            Console.WriteLine("b = {0}", b);
            Console.ReadLine();//结果a=0,b=0
        }
    }

二、赋值运算符

赋值运算符用于将值赋给变量。C#提供了多种赋值运算符，包括简单赋值和复合赋值运算符。

1. 赋值运算符概览

• 基本赋值
  • = 简单赋值
• 复合赋值
  • += 加法赋值
  • -= 减法赋值
  • *= 乘法赋值
  • /= 除法赋值
  • %= 模赋值
  • …

2. 示例

int x = 10;
x += 5; // 相当于 x = x + 5; 结果是15

int a = 5;
a += 3;  // a = a + 3 => a = 8
a -= 2;  // a = a - 2 => a = 6
a *= 2;  // a = a * 2 => a = 12
a /= 3;  // a = a / 3 => a = 4
a %= 2;  // a = a % 2 => a = 0

Console.WriteLine($"a = {a}");

三、比较/关系运算符

比较/关系运算符用于比较两个值的大小或相等性。它们返回布尔值（true 或 false）。常用于判断语句中。

1. 关系运算符概览

注：关系运算符的运算结果均是bool ，常运用于判断语句中

2. 示例

int m = 10, n = 20;
Console.WriteLine(m < n); // 输出: True

int a = 5;
int b = 3;

bool isEqual = a == b;  // false
bool isNotEqual = a != b; // true
bool isGreater = a > b;  // true
bool isLess = a < b;     // false

Console.WriteLine($"isEqual: {isEqual}, isNotEqual: {isNotEqual}, isGreater: {isGreater}, isLess: {isLess}");

四、逻辑运算符

逻辑运算符用于对布尔值进行逻辑操作，如与（AND）、或（OR）、非（NOT）。
用于在条件语句中组合多个条件。

1. 逻辑运算符概览

2. 注意事项

• 短路求值
  • 在逻辑与（&&）中，如果第一个操作数为false，则不会计算第二个操作数。
  • 在逻辑或（||）中，如果第一个操作数为true，则不会计算第二个操作数。
  • 例如，当&&运算符左边为false的时候，此时无论运算符右边是什么，结果都为false，那么右边表达式就不会运行。
• 避免短路
  • 单独使用| 和& 就不会产生短路的效果，即使左边已经起了决定性作用，右边仍会运行。

3. 示例

bool isSunny = true, isWarm = false;
Console.WriteLine(isSunny && !isWarm); // 输出: True

bool a = true;
bool b = false;

bool andResult = a && b; // false
bool orResult = a || b;  // true
bool notResult = !a;     // false

Console.WriteLine($"andResult: {andResult}, orResult: {orResult}, notResult: {notResult}");

五、位运算符

位运算符用于对整数的二进制位进行操作。它们在底层操作中非常高效。

1. 位运算符概览

2. 示例

		static void Main(string[] args)
        {
            //60 和13 转换位二进制分别是111100 和 1101 ，不足8位【前面】使用0补足
            int a = 60;            /* 60 = 0011 1100 */
            int b = 13;            /* 13 = 0000 1101 */
            int c = 0;

            c = a & b;
            // a      0011 1100
            // b      0000 1101
            //-----------------   根据&运算符规则：只有均为1的时候，结果才为1，否则均为0
            // c      0000 1100===>转换为十进制 则是12
            Console.WriteLine("Line 1 - c 的值是 {0}", c);

            c = a | b;
            // a      0011 1100
            // b      0000 1101
            //-----------------   根据|运算符规则：只有均为0的时候，结果才为0，否则均为1
            // c      0011 1101===>转换为十进制 则是61
            Console.WriteLine("Line 2 - c 的值是 {0}", c);

            c = a ^ b;
            // a      0011 1100
            // b      0000 1101
            //-----------------   根据^运算符规则：只有均为0或1的时候，结果才为0，否则均为1
            // c      0011 0001===>转换为十进制 则是49
            Console.WriteLine("Line 3 - c 的值是 {0}", c);

            c = ~a;               /*-61 = 1100 0011 */
            // a      0011 1100
            //取反-----------------   根据~运算符规则：将0变1 ，1变0
            // c      1100 0011===>转换为十进制 则是-61
            Console.WriteLine("Line 4 - c 的值是 {0}", c);

            c = a << 2;   
            // a      0011 1100
            //左移-----------------  0011 1100 向左移动两位则将前面两位00 移掉了，然后后面补足两位00
            // c      1111 0000===>转换为十进制 则是240
            Console.WriteLine("Line 5 - c 的值是 {0}", c);

            c = a >> 2;
            // a      0011 1100
            //右移-----------------  0011 1100 向右移动两位则将后面两位00 移掉了，然后前面补足两位00
            // c      0000 1111===>转换为十进制 则是15
            Console.WriteLine("Line 6 - c 的值是 {0}", c);
            Console.ReadLine();
        }

六、其他运算符

1. 条件运算符（?:）

条件运算符是一种简化的if-else语句，用于根据条件返回两个值中的一个。

语法：

条件表达式 ? 表达式1 : 表达式2

• 如果条件表达式为true，则返回表达式1的值。
• 如果条件表达式为false，则返回表达式2的值。

示例：

int age = 20;
string result = (age >= 18) ? "Adult" : "Minor";
Console.WriteLine(result); // 输出: Adult

int a = 5;
int b = 3;

int max = (a > b) ? a : b; // 如果 a > b，则 max = a，否则 max = b

Console.WriteLine($"Max: {max}");

2. 类型转换运算符

类型转换运算符用于将一个类型的值转换为另一个类型。C#提供了隐式类型转换和显式类型转换。

• 隐式类型转换：自动将低精度类型转换为高精度类型，不会丢失数据。

  int a = 5;
  double b = a; // 隐式转换：int 转换为 double
  

• 显式类型转换：需要使用强制类型转换，可能会丢失数据。

  double d = 10.5;
  int i = (int)d; // 将double转换为int，结果是10
  Console.WriteLine(i);
  

3. is 运算符

is 运算符检查表达式的结果是否与给定的类型相匹配。

 	public class Base { }
    public class Derived : Base { }
    class Program
    {
        static void Main(string[] args)
        {
            // 基类和派生类 之间的is 类型检查
            var b = new Base();
            Console.WriteLine(b is Base);//True
            Console.WriteLine(b is Derived);//False

            var d = new Derived();
            Console.WriteLine(d is Base);//True
            Console.WriteLine(d is Derived);//True

            //派生类可以是基类类型，is 检查返回True 
            //基类不可以是派生类的类型；
            //这个道理就像：兔子，狮子，小狗都可以用动物称呼，但是说所有动物都是小狗那就不行了

            //is 运算符将考虑装箱和取消装箱转换，但不会考虑数值转换
            int i = 27;
            object iBoxed = i;
            Console.WriteLine(iBoxed is int);  // output: True
            Console.WriteLine(iBoxed is long);  // output: False

            object obj = 99.9;
            if (obj is string s)
            {
                Console.WriteLine("结果："+s);
            }
            if (obj is double score)
            {
                Console.WriteLine("结果：" + score);
            }
            //以上案例说明：is的本质是 检查类型,通过检查返回True,反之，False
            
            //检查是否为null
            if (obj is null)
            {
                Console.WriteLine("**********");
            }

            //检查是否为非null
            if (obj is not null)
            {
                Console.WriteLine("**********");
            }
            Console.ReadLine();
        }
    }

4. as 运算符

as运算符将表达式显式转换为给定类型（如果其运行时类型与该类型兼容）
如果无法进行转换，则 as 运算符返回 null（as不能用于值类型，值类型不能为null）。
与强制转换表达式（形如(int)12） 不同，as 运算符永远不会引发异常。

			object obj1 = "121212";
            int le1 = (obj1 as string).Length;//可以转换

            object obj2 = null;
            int le2 = (obj2 as string).Length;//可以转换，但是由于转换后值为null,因此运行时会报错

            object obj3 = new object();
            string sr = obj as string;
            if (sr == null)
            {
                Console.WriteLine("转换失败");
            }
            else
            { 
                Console.WriteLine("转换成功");
            }
            //使用 as 转换的时候需要注意，转为结果为null的情况

            //is 对比 as 
            if (obj3 is string str3)
            {
                Console.WriteLine($"转换成功{str3}");
            }
            else
            {
                Console.WriteLine($"转换失败");
            }

5. typeof运算符

typeof运算符获取某个类型的 System.Type 实例。

public class Animal { }

public class Giraffe : Animal { }

public static class TypeOfExample
{
    public static void Main()
    {
        object b = new Giraffe();
        Console.WriteLine(b is Animal);  // output: True
        Console.WriteLine(b.GetType() == typeof(Animal));  // output: False

        Console.WriteLine(b is Giraffe);  // output: True
        Console.WriteLine(b.GetType() == typeof(Giraffe));  // output: True
    }
}

四、运算符优先级

1. 优先级

以下是C#中常见运算符的优先级（从高到低）：

1. 括号：()
2. 一元运算符：++、–、+（正号）、-（负号）、!、~
3. 乘除取模：*、/、%
4. 加减：+、-
5. 位移：<<、>>
6. 关系运算符：<、>、<=、>=
7. 相等性：==、!=
8. 位与：&
9. 位异或：^
10. 位或：|
11. 逻辑与：&&
12. 逻辑或：||
13. 条件运算符：? :
14. 赋值运算符：=, +=, -=, *=, /=, %= 等
15. 逗号运算符：,

辅助理解的案例代码如下：

//算术运算符和赋值运算符的优先级：
int a = 10, b = 5, c = 2;
a += b * c;               // 先计算乘法，再执行加法赋值
Console.WriteLine(a);       // 输出20

//逻辑运算符的优先级：
bool a = true, b = false, c = true;
bool result = a || b && c;  // 先计算与运算，再计算或运算
Console.WriteLine(result);  // 输出true

//条件运算符的优先级：
int a = 10, b = 5;
string result = a > b ? "a大于b" : "a不大于b";  // 先判断大小关系，再执行条件语句
Console.WriteLine(result);  // 输出"a大于b"

2. 优先级与常见问题

1. 运算符优先级（从高到低）：

   • 括号() > 单目运算符（!, ++, --, ~）> 算术运算符 > 移位 > 比较 > 逻辑与/或 > 条件运算符?: > 赋值运算符。

2. 易错点：

   • 整数除法陷阱：5 / 2结果为2，需显式转换为浮点类型。
   • 值类型与引用类型比较：==行为不同，需重写Equals方法。
   • 短路逻辑：&&和||可能跳过部分运算，避免副作用代码在右侧。

结语

回到目录页：C#/.NET 知识汇总
希望以上内容可以帮助到大家，如文中有不对之处，还请批评指正。

参考资料：
算术运算符（C# 参考）