C#表达式和运算符
本文我们将学习C#的两个重要知识点：表达式和运算符。本章内容会理论性稍微强些，我们会尽量多举例进行说明。建议大家边阅读边思考，如果还能边实践就更好了。
1. 表达式
说到表达式，大家可能感觉有些陌生，我们先来举个例子。在前面章节的示例代码中，大家一定见过类似这样的代码：i++，它其实就是一个表达式，其中的++是自增运算符，此表达式执行了自增运算让变量i自增1。我们现在来分析一下这个示例表达式的组成：
-
操作数，运算符的操作对象，这里是
i； -
运算符，指明对操作数做何种操作，这里是
++。
可见，上述表达式的形式是：操作数+运算符。表达式的定义是：具有一个或多个操作数，零个或多个运算符，可以计算且结果为单个值、对象、方法或命名空间的代码片段称作表达式。可见，一个表达式至少有1个操作数，运算符可以没有，且必须有计算结果。一个表达式中，可以包含简单的文本值、方法调用、运算符以及它的操作数，或者一个简单名称。这里的简单名称实际上是一个标识符，它可以是变量名、类型成员、方法参数、命名空间或者类型的名称，如图6-1所示。
由图6-1以及表达式的定义可知，运算符并非必需，下列所示代码也是合法的表达式，例如：
int x = 10;
string name = "Tom";这里的10和"Tom"就是简单的文本值，文本是没有名称的常数值，它们也是表达式。
表达式可以带有运算符，而运算符又可以将其他表达式用作参数，或者使用方法调用，而方法调用的参数又可以是其他方法调用。因此，表达式既可以非常简单，也可以非常复杂。
2. 运算符的类型
在C#中，运算符是术语或符号，它用于单个表达式，或者将多个表达式连接在一起，这些表达式所扮演的角色叫做"操作数"。运算符的重要作用之一就是计算1个或多个表达式，并把计算结果返回。运算符有多种类型，可以根据操作数的数量进行分类：
-
一元运算符：接受一个操作数的运算符称作一元运算符，例如增量运算符（
++）或new。 -
二元运算符：接受两个操作数的运算符称作二元运算符，例如算术运算符（
+、-、*、/）。 -
三元运算符：条件运算符（
? :）接受三个操作数，是C#中唯一的三元运算符。
下面我们分别举例进行说明，如图6-2所示。
图6-2中的语句包含3个二元运算符（=、+、*），它们分别有两个操作数。这3个二元运算符说明如下：
-
赋值运算符（
=）将一个整数（x）和一个表达式（10 + 2 * 3）作为操作数； -
表达式本身包含加和乘运算符，加（
+）运算符使用整数值10和表达式2 * 3作为操作数； -
乘（
*）运算符使用整数值2和3作为操作数。
需要说明的是操作数可以是任何大小的有效表达式。
3. 运算符的优先级
表6-1是C#中的全部运算符，根据操作类型分成了基本运算符、一元运算符、算术运算符等10个类别，并按照类别优先级进行排列。
此行我要插入图片3，做个标记输出给我。
当表达式中出现两个具有相同优先级的运算符时，它们根据结合性进行计算。左结合运算符按从左到右的顺序计算，例如，x * y / z计算为(x * y) / z。右结合运算符按从右到左的顺序计算。赋值运算符和三元运算符（? :）是右结合运算符。其他所有二元运算符都是左结合运算符。
4. 算术运算符
算术运算符有加、减、乘、除以及求余运算符，这里先学习简单的四则运算运算符，如表6-2所示。求余运算符将在6.5节讲述。
代码清单6-1给出了算术运算符的示例。
代码清单6-1 算术运算符示例
using System;
namespace ProgrammingCSharp4
{
class OperatorSample
{
int i1 = 10 + 20;
int i2 = 20 - 10;
int i3 = 10 * 20;
int i4 = 20 / 3;
double d1 = 1.1 + 2.2;
double d2 = 1.1 - 2.2;
double d3 = 1.1 * 2.2;
double d4 = 1.1 / 2.2;
static void Main()
{
OperatorSample os = new OperatorSample();
Console.WriteLine("i1={0}", os.i1);
Console.WriteLine("i2={0}", os.i2);
Console.WriteLine("i3={0}", os.i3);
Console.WriteLine("i4={0}", os.i4);
Console.WriteLine("d1={0}", os.d1);
Console.WriteLine("d2={0}", os.d2);
Console.WriteLine("d3={0}", os.d3);
Console.WriteLine("d4={0}", os.d4);
}
}
}运算结果为：
i1=30
i2=10
i3=200
i4=6
d1=3.3
d2=-1.1
d3=2.42
d4=0.55. 求余运算符
求余运算符是把第二个操作数除以第一个操作数，并返回余数。如果整除则返回余数0，不能整除则返回余数，如表6-3所示。
代码清单6-2给出了求余运算符的示例。
代码清单6-2 求余运算符示例
using System;
namespace ProgrammingCSharp4
{
class OperatorSample
{
int i1 = 0 % 20;
int i2 = 10 % 20;
int i3 = 20 % 20;
int i4 = 30 % 20;
static void Main()
{
OperatorSample os = new OperatorSample();
Console.WriteLine("0%20={0}", os.i1);
Console.WriteLine("10%20={0}", os.i2);
Console.WriteLine("20%20={0}", os.i3);
Console.WriteLine("30%20={0}", os.i4);
}
}
}输出如下：
0%20=0
10%20=10
20%20=0
30%20=106. 递增运算符和递减运算符
递增运算符对操作数增加1，递减运算符对操作数减去1，它们分别具有两种形式，分别是运算符前置和运算符后置，如表6-4所示。
我们通过一段代码来说明，如代码清单6-3所示。
代码清单6-3 递增运算符和递减运算符示例
using System;
namespace ProgrammingCSharp4
{
class OperatorSample
{
static void Main()
{
int i = 10;
int i1 = ++i;
Console.WriteLine("i={0}", i);
i = 10;
int i2 = i++;
Console.WriteLine("i={0}", i);
i = 10;
int i3 = --i;
Console.WriteLine("i={0}", i);
i = 10;
int i4 = i--;
Console.WriteLine("i={0}", i);
Console.WriteLine("++i={0}", i1);
Console.WriteLine("i++={0}", i2);
Console.WriteLine("--i={0}", i3);
Console.WriteLine("i--={0}", i4);
}
}
}输出如下：
i=11
i=11
i=9
i=9
++i=11
i++=10
--i=9
i--=10代码清单6-3的第9行定义了变量i，其值为10；第10行定义新的变量i1，执行i变量的前置递增操作（++i）；在第11行打印i的新值；第13行将i的值重新设置为初始值10；第14行执行i变量的后置递增操作（i++）；同样地，第15行打印i的新值。前置递减和后置递减同理，不再赘述。通过输出结果，我们可以看出，无论是前置还是后置，变量的值都是相同的，不同的就是整个表达式的返回值，如无论前置递增还是后置递增，i值都增加了1变为了11，而递减操作则变为了9，但前置递增返回的是新值11，后置递增返回的是旧值10。因此可以得出如下结论：
-
无论是前置还是后置（无论递增还是递减），操作数的值都发生了改变，且值相同（对于前置还是后置递增或递减而言）；
-
前置操作符返回表达式新值，后置操作符返回表达式旧值。
7. 关系和类型检测运算符
这里讨论的关系为大于、小于、大于等于、小于等于四种关系，等于和不等于关系在9节介绍。既然涉及比较，就意味着关系运算符是二元运算符，即必须有两个操作数。而且，关系运算符的结合性是左结合。
类型检测运算符为as和is。
关于关系运算符的说明，如表6-5所示。
由表6-5可知，使用了关系运算符的表达式返回bool类型的结果值：true或者false。
关系运算符的使用，如代码清单6-4所示。
代码清单6-4 关系运算符示例
using System;
namespace ProgrammingCSharp4
{
class OperatorSample
{
static void Main()
{
int i1 = 10;
int i2 = 10;
int i3 = 20;
Console.WriteLine("i1 >= i2 ? {0}", i1 >= i2);
Console.WriteLine("i1 > i2 ? {0}", i1 > i2);
Console.WriteLine("i1 < i3 ? {0}", i1 < i3);
Console.WriteLine("i1 <= i3 ? {0}", i1 <= i2);
}
}
}上述代码的运行结果为：
i1 >= i2 ? True
i1 > i2 ? False
i1 < i3 ? True
i1 <= i3 ? True8. 相等性判断运算符
相等性判断运算符（==、!=）也是二元运算符，并且是左结合，如表6-6所示。
对于值类型数据的判断，相等性判断的依据是两个操作数的值是否相等。而对于引用类型的操作数而言，大多数情况下比较的是它们的引用，而不管它们引用的对象有多么相似，甚至其值相同。
如图6-3所示，在第一个图中，引用a和引用b指向的是同一个对象------类1，因此它们是相等的；而对于第二个图，两个引用指向不同对象，因此它们不相等。但也有例外，string类型是引用类型，但string类型之间比较的是字符串长度和它们的值，其中值是大小写敏感的。
相等性运算符的示例如代码清单6-5所示。
代码清单6-5 相等性运算符示例
using System;
namespace ProgrammingCSharp4
{
class OperatorSample
{
static void Main()
{
int i1 = 10;
int i2 = 10;
int i3 = 20;
object o1 = i1;
object o2 = o1;
object o3 = i2;
object o4 = i1;
string s1 = "hello";
string s2 = "hello";
string s3 = "world";
Console.WriteLine("i1 == i2 ? {0}", i1 == i2);
Console.WriteLine("i1 != i3 ? {0}", i1 != i3);
Console.WriteLine();
Console.WriteLine("o1 == o2 ? {0}", o1 == o2);
Console.WriteLine("o1 == o3 ? {0}", o1 == o3);
Console.WriteLine("o1 != o3 ? {0}", o1 != o3);
Console.WriteLine("o1 == o4 ? {0}", o1 == o4);
Console.WriteLine();
Console.WriteLine("s1 == s2 ? {0}", s1 == s2);
Console.WriteLine("s1 == s3 ? {0}", s1 == s3);
}
}
}上述代码输出结果为：
i1 == i2 ? True
i1 != i3 ? True
o1 == o2 ? True
o1 == o3 ? False
o1 != o3 ? True
o1 == o4 ? False
s1 == s2 ? True
s1 == s3 ? False难点解析：
-
o1和o2都指向相同的object实例，因此它们是相等的。所以，o1 == o2返回true。 -
o1和o4都包装了相同的值（10），但是由于o1和o4是不同的对象实例，==操作符默认使用引用比较，比较的是它们是否是同一个实例，而不是它们的值。因此，o1 == o4返回false。
9. 条件运算符
条件运算符用于比较两个操作数的逻辑值，并返回一个逻辑值作为结果，如表6-7所示。
这些运算符的语法如下：
-
表达式1 && 表达式2 -
表达式1 || 表达式2 -
!表达式 -
布尔表达式 ? 结果1 : 结果2
需要说明的是，条件运算符使用"短路"计算模式。对于逻辑与运算符而言，如果第1个表达式结果为false，那么整个表达式的结果就已经确定了（false），第2个表达式将不会被执行，因此在第2个表达式中放置可能修改变量值的表达式是没有意义的。对于逻辑或运算符而言，如果第1个表达式结果为true，那么整个表达式的结果也已经确定了（true），因此第2个表达式同样不会被执行。
对于C#中唯一的三元运算符（? :）而言，首先计算布尔表达式的值，如果值为true，则整个表达式的结果取结果1，否则取结果2。
下面举例进行说明，如代码清单6-6所示。
代码清单6-6 条件运算符示例
using System;
namespace ProgrammingCSharp4
{
class OperatorSample
{
static void Main()
{
Console.WriteLine((1 == 0) && (1 == 1)); // False
Console.WriteLine((1 == 0) || (1 == 1)); // True
Console.WriteLine((1 == 0) || (1 == 2)); // False
Console.WriteLine(!(1 == 0)); // True
Console.WriteLine((1 == 0) ? 1 : 2); // 2
}
}
}上述代码输出结果为：
False
True
False
True
2在代码清单6-6中，第9行使用逻辑与运算符（&&），因为第1个表达式（1 == 0）结果为false，那么整个表达式的结果就已确定为false；第10行使用逻辑或运算符（||），虽然第1个表达式（1 == 0）结果为false，但第2个表达式（1 == 1）结果为true，因此整个表达式的结果为true；第11行使用逻辑或运算符，因为两个表达式的结果均为false，因此整个表达式的结果为false；第12行使用逻辑非运算符，因为表达式（1 == 0）的结果为false，那么整个表达式的结果为true；第13行使用三元条件运算符，因为第1个表达式（1 == 0）的结果为false，因此整个表达式的结果取第2个值------2，否则取第1个值。
10. 逻辑运算符
逻辑运算符除了"位与（&既可作为一元运算符也可以作为二元运算符）"和"位非（~）"以外，均为二元左结合运算符，如表6-8所示。
代码清单6-7演示了这些运算符的用法。
代码清单6-7 逻辑运算符示例
using System;
namespace ProgrammingCSharp4
{
class OperatorSample
{
static void Main()
{
int i1 = 100;
int i2 = 101;
Console.WriteLine("100 & 101 = {0}", i1 & i2);
Console.WriteLine("100 | 101 = {0}", i1 | i2);
Console.WriteLine("100 ^ 101 = {0}", i1 ^ i2);
Console.WriteLine("~100 = {0}", ~i1);
}
}
}上述代码的运行结果如下：
100 & 101 = 100
100 | 101 = 101
100 ^ 101 = 1
~100 = -101图6-4演示了上述代码的运算过程。
11. 位运算符
位运算符将操作符向左或者向右移动指定数目个位置，空出的位用0填充，如表6-9所示。
位运算符将第一个操作数向左或向右移动第二个操作数所指定的位数，其中第二个操作数的类型必须是int。向左移n位，相当于原值的2的n次方倍；向右移n位，相当于原值的2的n次方倍分之1。如图6-5所示，表达式100 << 2相当于100 × 2^2 = 400。
代码清单6-8演示了位运算符的使用。
代码清单6-8 位运算符示例
using System;
namespace ProgrammingCSharp4
{
class OperatorSample
{
static void Main()
{
int i1 = 100;
int i2 = i1 << 2;
Console.WriteLine(i2);
}
}
}输出结果如下：
400图6-5演示了上述代码的运算过程。
12. 赋值运算符
赋值运算符使用左右2个操作数，左侧的操作数为一个变量，右侧的操作数是一个有效的表达式，当右侧的表达式计算出结果，将会根据"赋值"运算符的类别，与左侧变量一起进行某种运算，然后把结果赋予左侧变量，具体如表6-10所示。
由表6-10可知，使用赋值运算符的语法如下：
复制
变量 赋值运算符 表达式;
其中，位与赋值运算符左边除了可以是变量以外，还可以为以下类型：
-
属性（类级别字段，带访问器）
-
索引
-
事件
基本赋值运算符（=）我们已经使用了很多次，相信大家已经熟悉了，如：
int i1 = 100;
int i2 = 101;意即将100赋给int类型的变量i1，将101赋给int类型变量i2。另外一种情况可能比简单赋值稍微复杂些，就是首先计算一个表达式的值，然后将它和某个变量一起进行计算。主要有两种方式：
-
将表达式的值使用基本赋值运算符赋给某一个变量，然后将该变量和既定变量进行计算；
-
使用复合赋值运算符，如
+=、-=、*=等等。
以下两种方式是等价的：
i = i + 100;
i += 100;显然，第2种方式更简洁。其中+=运算符还可以连接两个字符串，如：
string s = "Hello";
s += "world!";
Console.WriteLine(s);下面两种方式也是等价的，这说明复合赋值运算符操作的是右侧表达式的计算结果，而不是其中某个操作数。
i3 *= i1 + i2;
i3 *= (i1 + i2);这里有一个特殊的赋值运算符??，它是一个二元运算符，当左操作数为空时返回右操作数，否则返回左操作数。需要注意的是，该运算符只能应用于引用类型或Nullable（可空）类型，如：
string a = "hello world!";
string b = a ?? "hello C#!";
Console.WriteLine(b);上述代码的运行结果为：
hello world!13. typeof运算符
typeof是一元运算符，用于返回任意一个类型的类型信息（使用System.Type对象表示），如表6-11所示。
typeof运算符的语法如下：
Type type = typeof(类型);下面，通过一个示例来看看typeof运算符的用法，如代码清单6-9所示。
代码清单6-9 typeof运算符示例
using System;
using System.Reflection;
namespace ProgrammingCSharp4
{
class OperatorSample
{
static void Main()
{
Type t = typeof(OperatorSample);
Console.WriteLine("方法：");
MethodInfo[] methodInfo = t.GetMethods();
foreach (MethodInfo mInfo in methodInfo)
{
Console.WriteLine(mInfo.ToString());
}
Console.WriteLine("成员：");
MemberInfo[] memberInfo = t.GetMembers();
foreach (MemberInfo mInfo in memberInfo)
{
Console.WriteLine(mInfo.ToString());
}
}
}
}上述代码的输出结果如下：
方法：
System.String ToString()
Boolean Equals(System.Object)
Int32 GetHashCode()
System.Type GetType()
成员：
System.String ToString()
Boolean Equals(System.Object)
Int32 GetHashCode()
System.Type GetType()
Void.ctor()14. 运算符重载
前面讲的运算符都有一个共同点，即它们只能使用框架预定义类型作为操作数，如果想要对自定义类型进行操作该怎么办呢？和C++一样，C#同样支持运算符重载，以处理此类问题。例如，可以创建一个名为ComplexNumber的新数据类型来表示一个复杂的数字，并提供使用标准算术运算符对此类数字执行数学运算的方法，如使用加（+）运算符将两个复杂数字相加。
可见，使用运算符重载给开发人员带来了如下好处：
-
使代码更加容易理解和阅读；
-
可以利用现有运算符的优先级关系规则处理对象之间的运算；
-
使代码更加灵活，对象可操作性更好。
下面将详细阐述如何实现运算符重载。
14.1 运算符的重载
运算符重载只能应用于类或结构。要重载一个运算符，可以声明一个名为operator x的方法并实现它，如operator+和operator-，一元运算符和二元运算符都可以被重载，相应地，重载方法分别带一个或两个参数（类或结构类型），其语法为：
// 一元运算符重载
public static 自定义类型 operator 要重载的运算符(类型)
// 二元运算符重载
public static 自定义类型 operator 要重载的运算符(类型1, 类型2)如：public static OperatorSample operator+(OperatorSample obj)。
需要注意的是，所有运算符重载均为类的静态方法，且必须使用public进行修饰。
注意：重载相等运算符（==）时，还必须重载不相等运算符（!=）。<和>运算符以及<=和>=运算符也必须成对重载。
下面是一个运算符重载的示例，如代码清单6-10所示。我们为OperatorSample类重载了加（+）运算符，实现了可以使用加运算符来实现两个OperatorSample对象的相加功能，可见运算符重载很大程度上提高了编程的便利性。通过重载运算符，可以使用更熟悉或更自然的方式来操作两个自定义对象。
代码清单6-10 运算符重载示例
using System;
namespace ProgrammingCSharp4
{
class OperatorSample
{
public int Value { get; set; }
static void Main()
{
OperatorSample o1 = new OperatorSample();
o1.Value = 10;
OperatorSample o2 = new OperatorSample();
o2.Value = 20;
OperatorSample o3 = o1 + o2;
Console.WriteLine(o3.Value);
}
public static OperatorSample operator +(OperatorSample o1, OperatorSample o2)
{
OperatorSample o = new OperatorSample();
o.Value = o1.Value + o2.Value;
return o;
}
}
}上述代码的运行结果如下：
3014.2 可重载的运算符
并非所有的运算符都可以重载，以下是可重载的运算符：
-
一元运算符：
+、-、!、~、++、--、true、false； -
二元运算符：
+、-、*、/、%、&、|、^、<<、>>、==、!=、>、<、>=、<=。
其他还有一些运算符，虽然不能重载，但有相应的替代方案，例如：条件逻辑运算符不能重载，但可使用能够重载的&和|进行计算；数组索引运算符不能重载，但可定义索引器；转换运算符不能重载，但可定义新的转换运算符（使用explicit和implicit关键字）。
最后，我们再列出不能重载的运算符，如：=、.、? :、->、new、is、sizeof和typeof。