《Visual C# 最佳实践》第一章 程序设计 (四)：运算符

第一章 程序设计

　　“要想成为真正的程序员，我们需要进行一场洗礼。”
　　“程序 = 数据结构 + 算法。”这样的公式很精辟，它越过了表层直接描述了程序的本质。不仅如此，这样几个简单的单词也让我们明白“我们应该学习什么内容？”。人们做任何事都有一定的程序，只是没有意识到。有些人将日常行动列成表格，这就是“编写程序”。

 

本章的学习重点：

　　◆    运算符分类
　　◆    运算符优先级

 

1.4运算符

　　表达式 (expression) 由操作数 (operand) 和运算符 (operator) 构成。表达式的运算符用来指示对操作数进行什么样的运算。常用的运算符包括 +、-、*、/ 和 %等。操作数由变量和常量构成。常量我们在后面的章节会向大家讲到，这里主要向大家介绍运算符的相关知识，希望对大家有所帮助。

 

1.4.1运算符分类

　　运算符是表达式中相当重要的一部分，它指示对表达式中的操作数进行什么样的运算，如+、–、*、/、%等。根据运算符操作的个数，可以把运算符分为以下3类：
　　一元运算符：只带有一个操作数并使用前缀表示法（如--x）或后缀表示法（如x++）。
　　二元运算符：带有两个操作数并且全都使用中缀表示法（如x+y）。
　　三元运算符：带有3个操作数并使用中缀表示法（如 ?: 运算符）。注意：C#语言只包含一个三元运算符。
　　下表列出了C#常见运算符：
　　　类别     　　　 　　运算符
　　算术运算符    　　　  + – * / %
　　逻辑运算符    　　　  & | ^ ~ && || !
　　字符串连接运算符　　+
　　增量和减量运算符　　++ – –
　　移位运算符　　　　   << >>
　　比较运算符    　　　   == != < > <= >=
　　赋值运算符    　　　　= += –= *= /= %= &= |= ^= <<= >>=
　　成员访问运算符    　　.
　　索引运算符    　　　　[]
　　数据类型转换运算符    ()
　　条件运算符    　　　　?:
　　委托连接和删除运算符 + –
　　对象创建运算符    　　New
　　类型信息运算符    　　sizeof (只用于不安全的代码) is typeof as
　　溢出异常控制运算符    checked unchecked
　　间接寻址运算符    　　* –> & (只用于不安全代码) []
　　命名空间别名限定符    ::
　　空接合运算符    　　　??
　　!、++x、--x和(T)x被称为一元运算符。其中，(T)x运算符为强制转换运算符，它可以将一种类型转换为另外一种类型。下面我们详细介绍!、++x、--x和(T)x运算符以及其他运算符的使用方法。
　　1、++运算符
　　++运算符又称为增量运算符，它既可以放到操作数的左边，也可以放到操作数的右边。如果++运算符放在操作数的左边，则称为该运算符为前缀增量运算符。否则，称为后缀增量运算符。语法如下：
　　++ expression或expression++
　　expression表示操作数。“++ expression”表达式首先计算expression的值，然后将其值增1，并作为该表达式的结果。“expression ++”表达式首先计算expression的值，并作为该表达式的结果，然后将expression的值增1。下面我们来看一个范例：
　　01 using System;
　　02 namespace Microsoft.Example
　　03 {
　　04     public class TestIncrement
　　05     {
　　06         public static void Main(string[] args)
　　07         {
　　08             int a = 2008;        //定义一个a变量
　　09             int b = ++a;        //进行前缀增量运算，并定义一个b变量保存结果
　　10             int c = a++;        //进行后缀增量运算，并定义一个c变量保存结果
　　11             Console.WriteLine("a的值为：" + a);        //输出结果
　　12             Console.WriteLine("b的值为：" + b);        //输出结果
　　13             Console.WriteLine("c的值为：" + c);        //输出结果
　　14         }
　　15     }
　　16 }
　　上述代码中，第9行“++a”表达式执行之后，a变量的值为2009，并作为该表达式的值。因此，b变量的值为等于2009。第10行“c = a++”表达式首先获取a变量的值，并赋值给c变量，因此，c变量的值为2009。然后，再将a变量的值增1。因此，a变量的值为2010。
　　最后的输出结果：
　　a的值为：2010
　　b的值为：2009
　　c的值为：2009
　　2、--运算符
　　--运算符又称为减量运算符，它既可以放到操作数的左边，也可以放到操作数的右边。如果--运算符放在操作数的左边，则称为该运算符为前缀减量运算符。否则，称为后缀减量运算符。语法如下：
　　-- expression或expression--
　　expression表示操作数。“-- expression”表达式首先计算expression的值，然后将其值减1，并作为该表达式的结果。“expression --”表达式首先计算expression的值，并作为该表达式的结果，然后将expression的值减1。下面我们来看一个范例：
　　01 using System;
　　02 namespace Microsoft.Example
　　03 {
　　04     public class TestDeduction
　　05     {
　　06         public static void Main(string[] args)
　　07         {
　　08             int a = 2008;       //定义一个a变量
　　09             int b = --a;        //进行前缀减量运算，并定义一个b变量保存结果
　　10             int c = a--;        //进行后缀减量运算，并定义一个c变量保存结果
　　11             Console.WriteLine("a的值为：" + a);     //输出结果
　　12             Console.WriteLine("b的值为：" + b);     //输出结果
　　13             Console.WriteLine("c的值为：" + c);     //输出结果
　　14         }
　　15     }
　　16 }
　　上述代码中，第9行“-- a”表达式执行之后，a变量的值为2007，并作为该表达式的值。因此，b变量的值为等于2007。第10行“c = a --”表达式首先获取a变量的值，并赋值给c变量，因此，c变量的值为2007。然后，再将a变量的值减1。因此，a变量的值为2006。
　　最后的输出结果：
　　a的值为：2006
　　b的值为：2007
　　c的值为：2007
　　3、!运算符
　　!运算符又称为逻辑否定运算符。如果操作数的值为true，则结果为false。如果操作数为false，则结果为true。语法如下：
　　! expression
　　expression表示操作数。只能使用布尔类型的数据，不能使用其它数据类型使用!运算符，负责编译会出现错误。下面我们来看一个范例：
　　01 using System;
　　02 namespace Microsoft.Example
　　03 {
　　04     public class TestNot
　　05     {
　　06         public static void Main(string[] args)
　　07         {
　　08             bool a = true;          //定义一个a变量
　　09             bool b = !a;            //进行逻辑否定运算，并定义一个b变量保存结果
　　10             Console.WriteLine("a的值为：" + a);     //输出结果
　　11             Console.WriteLine("b的值为：" + b);     //输出结果
　　12         }
　　13     }
　　14 }
　　上述代码中，第9行“!a”表达式执行之后，a变量的值为false，并作为表达式的值。因此，b变量的值为等于false。
　　最后的输出结果：
　　a的值为：True
　　b的值为：False
　　4、(T)x运算符
　　(T)x运算符将表达式显式转换为指定的类型，语法如下：
　　( type ) expression
　　type表示类型，expression表示被转换的表达式。下面我们来看一个范例：
　　01 using System;
　　02 namespace Microsoft.Example
　　03 {
　　04     public class TestConvertTypes
　　05     {
　　06         public static void Main(string[] args)
　　07         {
　　08             object o = 2009;        //定义一个o变量
　　09             int i = (int)o;            //进行显式转换
　　10             Console.WriteLine("i的值为：" + i);
　　11         }
　　12     }
　　13 }
　　上述代码中，第9行(int)o进行了显示类型转换，把o变量的值转换为int类型。注意：对于( T )x表达式而言，不存在从x的类型到T的显式转换，会发生编译错误的。
　　最后的输出结果：
　　i的值为：2009
　　5、算术运算符
　　*、/、%、+和–运算符称为算术运算符，它们分别表示乘法、除法、余数、加法和减法运算。语法如下：
　　left expression operator right expression
　　left expression和right expression分别表示左操作数和右操作数，operator表示运算符，可以为*、/、%、+和–。下面我们来看一个范例：
　　01 using System;
　　02 namespace Microsoft.Example
　　03 {
　　04     public class TestNumber
　　05     {
　　06         public static void Main(string[] args)
　　07         {
　　08             int a = 1;          //定义a变量
　　09             int b = 1;          //定义a变量
　　10             int c = a + b;       //进行算术运算
　　11             Console.WriteLine("c的值为：" + c);     //输出结果
　　12         }
　　13     }
　　14 }
　　上述代码中，a变量的值为1，b变量的值为1，执行+运算之后，c变量的值为等于2。如果左、右操作数的类型相同，则它们的运算结果的类型和操作数的类型相同。当运算结果超出了该类型表示的范围时，如果使用了checked运算符，则引发System.OverflowException异常。如果使用了unchecked运算符，则不引发异常，但是其结果类型范围外的任何有效高序位都被放弃。
　　最后的输出结果：
　　c的值为：2
　　对于+运算符而言，如果其一个或两个操作数为string类型时，则+运算符执行字符串串联操作，而不是简单的算术运算。下面我们来看一个范例：
　　01 using System;
　　02 namespace Microsoft.Example
　　03 {
　　04     public class TestString
　　05     {
　　06         public static void Main(string[] args)
　　07         {
　　08             string stra = "2008";            //定义一个stra变量
　　09             string strb = ".08.08";        //定义一个stra变量
　　10             string strc = stra + strb;        //进行连接字符串运算
　　11             Console.WriteLine(strc);        //输出结果
　　12         }
　　13     }
　　14 }
　　上述代码中，第8行和第9行分别定义了一个字符串变量stra和strb。然后我们使用+运算符进行运算，把运算结果保存在strc中。strc变量的值为2008.08.08字符串。
　　6、逻辑运算符
　　&、^和 | 运算符称为逻辑运算符。&运算符计算两个操作数的按位逻辑AND，| 运算符计算两个操作数的按位逻辑OR，^ 运算符计算两个操作数的按位逻辑XOR。语法如下：
　　left expression operator right expression
　　left expression和right expression分别表示左操作数和右操作数，operator表示运算符，可以为&、^和 |。下面我们来看一个范例：
　　01 using System;
　　02 namespace Microsoft.Example
　　03 {
　　04     public class TestLogic
　　05     {
　　06         public static void Main(string[] args)
　　07         {
　　08             bool a = true;          //定义一个a变量
　　09             bool b = false;         //定义一个a变量
　　10             bool c = a & b;         //进行逻辑与运算
　　11             Console.WriteLine("c变量的值为" + c);        //输出结果
　　12         }
　　13     }
　　14 }
　　上述代码中，第10行我们进行了逻辑运算，具体规则如下：
　　如果a和b均为true，则a & b的结果为true。否则，结果为false。
　　如果a或b为true，则a | b的结果为true。否则，结果为false。
　　如果a为true而b为false，或者a为false而b为true，则a ^ b的结果为true。否则，结果为false。即a和b的值不相同时，a ^ b的结果才为true。
　　最后的输出结果：
　　c变量的值为false。
　　7、条件运算符
　　?: 运算符称为条件运算符，它是C#语言中唯一的一个三元运算符。语法如下：
　　expression ? trueResult : falseResult;
　　该表达式首先计算条件表达式的值。如果条件表达式的值为真，则trueResult的值，并成为运算结果。否则计算falseResult，并成为运算结果。下面我们来看一个范例：  
　　01 using System;
　　02 namespace Microsoft.Example
　　03 {
　　04     public class TestCondition
　　05     {
　　06         public static void Main(string[] args)
　　07         {
　　08             int a = 10;                        //定义一个a变量
　　09             int b = 2008;                    //定义一个b变量
　　10             int c = a + b > 3000 ? a : b;        //进行条件运算
　　11             Console.WriteLine("c变量的值为" + c);        //输出结果
　　12         }
　　13     }
　　14 }
　　上述代码中，第10行如果a + b表达式的值大于3000时，则c的值等于a的值，否则c的值等于b的值。
最后的输出结果：
　　c变量的值为2008
　　8、条件逻辑运算符
　　&& 和 || 运算符称为条件逻辑运算符。&& 运算符为逻辑与运算符，它计算左右操作数的逻辑与。|| 运算符为逻辑或运算符，它计算左右操作数的逻辑或。语法如下：
　　left expression operator right expression
　　left expression和right expression分别表示左操作数和右操作数。operator表示运算符，可以为&&和||。
　　示例：使用&&运算符计算a和b两个操作数（均为bool类型）的和，结果保存为c变量。
　　bool a = true;
　　bool b = false;
　　bool c = a && b;
　　分析：c变量的值为false。
　　注意：对于a && b表达式而言，仅当a的值为true时，才计算b的值。对于a || b表达式而言，仅当a的值为false时，才计算b的值。
　　9、移位运算符
　　<<和>>运算符被称为移位运算符。<<运算符表示左移位，>>运算符表示右移位。语法如下：
　　expression operator count;
　　expression表示被移位的表达式，count表示移动的位数，operator表示运算符，可以为<<和>>。
　　下面我们来看一个范例：
　　01 using System;
　　02 namespace Microsoft.Example
　　03 {
　　04     public class TestMove
　　05     {
　　06         public static void Main(string[] args)
　　07         {
　　08             int a = 2008;       //定义一个a变量
　　09             int c1 = a << 2;    //进行向左移位
　　10             int c2 = a >> 2;    //进行向右移位
　　11             Console.WriteLine("c1变量的值为" + c1);        //输出结果
　　12             Console.WriteLine("c2变量的值为" + c2);        //输出结果
　　13         }
　　14     }
　　15 }
　　上述代码中，a << count表达式将a向左移位count个位。计算方法为：放弃a中经移位后的高序位（如果保留这些高序位，则结果将超出结果类型的范围），将其余的位向左位移，并将空出来的低序位均设置为零。a >> count表达式将a向右移位count个位。计算方法如下：
　　当a为int或long类型时，放弃a的低序位，将剩余的位向右位移。如果x非负，则将高序空位位置设置为零。如果a为负，则将其设置为1。
　　当a为uint或ulong类型时，放弃a的低序位，将剩余的位向右位移，并将高序空位位置设置为零。
　　最后的输出结果：
　　c1变量的值为8032
　　c2变量的值为502
　　10、关系和类型测试运算符
　　==、!=、<、>、<=、>=、is和as运算符称为关系和类型测试运算符。语法如下：
　　left expression operator right expression
　　left expression和right expression分别表示左操作数和右操作数，operator表示运算符，可以为==、!=、<、>、<=、>=、is和 as。其中，==、!=、<、>、<=和>=运算符为比较运算符，它们的具体计算方法如下：
　　x == y，如果x等于y，则为true，否则为false。
　　x != y，如果x不等于y，则为true，否则为false。
　　x < y，如果x小于y，则为true，否则为false。
　　x > y，如果x大于y，则为true，否则为false。
　　x <= y，如果x小于等于y，则为true，否则为false。
　　x >= y，如果x大于等于y，则为true，否则为false。
　　注意：==、!=、<、>、<=和>=运算符的结果均为bool类型。
　　下面我们来看一个范例：   
　　01 using System;
　　02 namespace Microsoft.Example
　　03 {
　　04     public class TestCompare
　　05     {
　　06         public static void Main(string[] args)
　　07         {
　　08             int a = 10;         //定义一个a变量
　　09             int b = 2008;       //定义一个b变量
　　10             bool c = (a == b);  //进行比较运算，然后把结果赋予c变量
　　11             Console.WriteLine("c变量的值为" + c);        //输出结果
　　12         }
　　13     }
　　14 }
　　上述代码中，第10行中使用==运算符进行比较，如果a等于b，得到的结果是true，如果a不等于b，则得到的结果是false。
　　最后的输出结果：
　　c变量的值为False
　　11、is运算符
　　is运算符用于动态检查对象的运行时类型是否与给定类型兼容，其结果也为bool类型。对于“e is T”表达式而言（其中，e为表达式，T为类型），如果e的结果能够隐式转换为T类型，则该表达式的结果为true，否则为false。
　　下面我们来看一个范例：
　　1 using System;
　　2 namespace Microsoft.Example
　　3 {
　　4     public class TestIs
　　5     {
　　6         static void Main()
　　7         {
　　8             int a = 10;                //定义一个a变量
　　9             bool c = a is object;        //进行is运算
　　10             Console.WriteLine("c变量的值为" + c);
　　11         }
　　12     }
　　13 }
　　上述代码中， 第9行我们使用is运算符，判断a是否是object类型，我们知道，所有的类型都是继承于object类型的，所有is运算出来的结果是true。
　　最后的输出结果：
　　c变量的值为true。
　　12、as运算符
　　as运算符用于将一个值显式地转换为一个给定的引用类型。如果转换失败，则返回null。
　　下面我们来看一个范例：
　　1 using System;
　　2 namespace Microsoft.Example
　　3 {
　　4     public class TestIs
　　5     {
　　6         static void Main()
　　7         {
　　8             int a = 10;                //定义一个a变量
　　9             object c = a as object;        //进行as运算
　　10            Console.WriteLine("c变量的值为" + c.GetType());
　　11         }
　　12     }
　　13 }
　　上述代码中，第9行我们进行了as运算符的运算，把a整数转换为object类型。这里我们需要注意到是，这里转换的是类型的引用，实际内容并没有变化，我们通常称这种行为为装箱操作，这个我们在后面会讲到。as运算符从不引发异常。对于“e as T”表达式而言，e必须是表达式，T必须是引用类型，且运算结果总是能够归属于T类型。
　　最后的输出结果：
　　c变量的值为System.Int32
　　13、赋值运算符
　　=、*=、/=、%=、+=、-=、<<=、>>=、&=、^=和|=运算符被称为赋值运算符，它们能够为变量、属性、事件或索引器元素赋新值。语法如下：
　　left expression operator right expression
　　left expression和right expression分别表示左操作数和右操作数，operator表示运算符，如=、*=、/=等。
　　示例：使用*=运算符计算两个操作数（a和b，它们的值分别为10和2008）的乘积，并赋值给左操作数b。
　　int a = 10,b =2008;
　　int b *= a;
　　分析：b变量的值为20080。
　　注意：赋值运算符的左操作数必须是属于变量、属性访问、索引器访问或事件访问类别的表达式。
　　=运算符称为简单赋值运算符，它将右操作数的值赋予左操作数给定的变量、属性或索引器元素。op=运算符称为复合赋值运算符，“x op= y”表达式相当于“x = x op y”表达式。
　　下面列出了C#中的全部简化赋值运算符。
　　运算符的简化操作    等 价 于
　　x++, ++x    　　　x = x + 1
　　x– –,– –x    　　　x = x – 1
　　x+= y    　　　　   x = x + y
　　x–= y    　　　　　x = x – y
　　x *= y    　　　　  x = x * y
　　x /= y    　　　　　x = x / y
　　x %= y    　　　　 x = x % y
　　x >>= y    　　　　x = x >> y
　　x <<= y    　　　　x = x << y
　　x &= y    　　　　  x = x & y
　　x |= y    　　　　　x = x | y
　　x ^= y    　　　　  x = x ^ y
　　为什么用两个例子来说明++增量和– –减量运算符？把运算符放在表达式的前面称为前置，把运算符放在表达式的后面称为后置。它们的执行方式有所不同。

 

1.4.2运算符优先级

　　当表达式包含多个操作符时，操作符的优先级控制着操作符的计算顺序。例如，表达式x+y*z按x+(y*z)计算，因为操作符*的优先级比+高。操作符的优先级由操作符的相关表达式的定义来确定。
　　下面概述了这些运算符，并将它们按优先级以从高到低的顺序列出：
　　基本 x.y f(x) a[x] x++ x-- new typeof checked unchecked
　　一元 + - ! ~ ++x --x (T)x
　　乘法 * / %
　　加法 + -
　　移位 << >>
　　关系和类型检测 <? >? <=? >=? is? as
　　相等 == !=
　　逻辑 XOR ^
　　逻辑 OR |
　　条件 AND &&
　　条件 OR ||
　　条件 ? :
　　赋值 = *= /= %= += -= <<=? >>= &= ^= |=
　　当操作数出现在具有相同优先级的两个运算符之间时，运算符的执行顺序：
　　除了赋值运算符外，所有的二元运算符都向左顺序关联，意思是从左向右执行运算。例如，x + y + z 按 (x + y) + z 计算。
　　赋值运算符和条件运算符 (?:) 向右顺序关联，意思是从右向左执行运算。例如，x = y = z 按 x = (y = z) 计算。
　　优先级和顺序关联性都可以用括号控制。例如，x + y * z 先将 y 乘以 z 然后将结果与 x 相加，而 (x + y) * z 先将 x 与 y 相加，然后再将结果乘以 z。
　　在复杂的表达式中，应避免利用运算符优先级来生成正确的结果。使用括号指定运算符的执行顺序，可以使代码更整洁，避免出现潜在的冲突。