◆本章简述
表达式在C#程序中应用广泛，尤其是在计算功能中，往往需要大量的表达式。而大多数表达式都使用运算符，运算符结合一个或一个以上的操作数，便形成了表达式，并且返回运算结果。本章将对C#中的表达式与运算符进行详细讲解。
◆本章内容
（1）了解什么是表达式
（2）熟悉算术运算符的使用
（3）掌握赋值运算符
（4）掌握如何使用关系运算符
（5）掌握逻辑运算符的使用方法
（6）掌握如何对变量进行位操作
（7）掌握其他特殊运算符的使用方法
（8）熟悉运算符的优先级顺序
◆知识框架
4.1 表达式
表达式是由运算符和操作数组成的。运算符设置将对操作数进行什么样的运算？例如，“+”“-”“*”和“/”都是运算符，操作数包括文本、常量、变量和表达式等。
例如，下面几行代码就是简单的表达式。
int i = 927;//声明一个int类型的变量i并初始化为927 i = i * i + 112;//改变变量i的值 int j = 2020;//声明一个int类型的变量j并初始化为2020 j = j / 2;//改变变量j的值
在C#中，如果表达式最终的计算结果为所需的类型值，表达式就可以出现在需要值或对象的任意位置。
[例4.1]创建一个控制台应用程序，声明两个int类型的变量i和j,并将其分别初始化为927和112，然后输出i*i+j*j的正弦值，代码如下。
int i = 927;//声明一个int类型的变量i并初始化为927 int j = 112;//声明一个int类型的变量j并初始化为112 Console.WriteLine(Math.Sin(i * i + j * j));//表达式作为参数输出 Console.ReadLine();
程序的运行结果为：
在上面的代码中，表达式i*i+j*j作为方法Math.Sin的参数来使用，同时，表达式Math.Sin(i*i+j*j)还是方法Console.WriteLine的参数。
4.2 运算符
运算符是一些特殊的符号，主要用于数学函数、一些类型的赋值语句和逻辑比较方面。C#中提供了丰富的运算符，如算术运算符、赋值运算符、比较运算符等。本节将向读者介绍这些运算符。
4.2.1 算术运算符
“+”“-”“*”“/”和“%”运算符都称为算术运算符，分别用于进行加、减、乘、除和模(求余数)运算。C#中的算术运算符的功能及使用方式如表4.1所示。
|
表4.1 C#中的算术运算符的功能及使用方法 |
|||
|
运算符 |
说明 |
实例 |
结果 |
|
+ |
加 |
12.45f+15 |
27.45 |
|
- |
减 |
4.56-0.16 |
4.4 |
|
* |
乘 |
5L*12.45f |
62.25 |
|
/ |
除 |
7/2 |
3 |
|
% |
取余数 |
12%10 |
2 |
其中，“+”和“-”运算符还可以作为数据的正负符号，如+5、-7。
说明：算术运算的结果类型取决于操作数类型。例如，表达式5.0/2.0的值是2.5。两个操作数的类型均是double，结果也是double。(在C#中，带小数点的字面值肯定是double值，而不是float值，目的是保留尽可能高的精度。)但表达式5/2的结果是2。两个操作数的类型均是int,结果也是int。C#在这种情况下总是对值进行向下取整。另外，混用不同的操作数类型，情况会变得更复杂。例如，表达式5/2.0包含int值和double值。C#编译器检测到这种不一致的情况，自动生成代码将int转换成double再执行计算。所以，以上表达式的结果是double值(2.5)。能这样写，但不建议。
1. 加法运算符
加法运算符（+）通过两个数相加来执行标准的加法运算。
[例4.2]创建一个控制台应用程序，声明两个整型变量numl和num2,并将numl赋值为927,然后使num2的值为num1与num1相加之后的值，代码如下。
static void Main(string[] args) { int num1 = 927;//声明整型变量num1,并赋值为927 int num2;//声明整型变量num2 num2 = num1 + num1;//num2的值为num1与num1相加之后的值 Console.WriteLine(num2.ToString()); Console.Read(); }
程序的运行结果为：
说明：如果想要对整型变量num进行加1操作，可以用“num= num+1;”来实现，也可以用增量运算符(++)实现，如num++或++num。++num是前缀增量操作，该操作的结果是操作数加1之后的值；num++是后缀增量操作，该运算的结果是操作数增加之前的值。
2. 减法运算符
减法运算符（-）通过从一个表达式中减去另一个表达式的值来执行标准的减法运算。
[例4.3]创建一个控制台应用程序，声明两个decimal类型变量numl和num2，并分别赋值为1112.82和9270.81,然后再声明一个decimal类型变量num3，使其值为num2减去numl之后得到的值，代码如下。
static void Main(string[] args) { decimal num1 = (decimal)1112.82;//声明整型变量num1,并赋值为1112.82 decimal num2 = (decimal)9270.81;//声明整型变量num2,井赋值为9270.81 decimal num3;//声明整型变量num3 num3 = num2 - num1;//num3的值为num2减去num1得到的值 Console.WriteLine(num3.ToString()); Console.Read(); }
程序的运行结果为：
说明：如果想要对整型变量num进行减1操作，可以用“num=num-1;”来实现，也可以用减量运算符(--)实现，如num--或--num。--num是前缀减量操作，该操作的结果是操作数减1之后的值；num--是后缀减量操作，该运算的结果是操作数减少之前的值。
3. 乘法运算符
乘法运算符（*）将两个表达式进行乘法运算并返回它们的乘积。
[例4.4]创建一个控制台应用程序，声明两个整型变量numl和num2,并分别赋值为10和20。再声明一个整型变量sum,使其值为numl和num2的乘积，代码如下。
static void Main(string[] args) { int num1 = 10;//声明整型变量num1,并赋值为10 int num2 = 20;//声明整型变量num2,并赋值为20 int sum;//声明整型变量sum sum = num1 * num2;//使sum的值为num1和num2的乘积 Console.WriteLine(sum.ToString()); Console.Read(); }
程序的运行结果为：
4. 除法运算符
除法运算符（/）执行算术除运算，它用被除数表达式除以除数表达式而得到商。
[例4.5]创建一个控制台应用程序，声明两个整型变量numl和num2,并分别赋值为45和5。再声明一个整型变量result,使其值为num1除以num2得到的值,代码如下。
static void Main(string[] args) { int num1 = 45;//声明整型变量num1,并赋值为45 int num2 = 5;//声明整型变量num2,井赋值为5 int result;//声明整型变量result result = num1 / num2;//使result的值为num1除以num2得到的值 Console.WriteLine(result.ToString()); Console.Read(); }
程序的运行结果为：
注意：在用算术运算符(+、-、*、/) 运算时，产生的结果可能会超出所涉及数值类型的值的范围，这样，会导致运行结果不正确。
5. 求余运算符
求余运算符(%)返回除数与被除数相除之后的余数，通常用这个运算符来创建余数在特定范围内的等式。
[例4.6]创建一个控制台应用程序,声明两个整型变量numl和num2,并分别赋值为55和10。再声明一个整型变量result,使其值为num1与mum2求余运算之后的值，代码如下。
static void Main(string[] args) { int num1 = 55;//声明整型变量num1,井赋值为55 int num2 = 10;//声明整型变量num2,井赋值为10 int result;//声明整型变量result result = num1 % num2;//使result等于num1与num2求余运算之后的值 Console.WriteLine(result.ToString()); Console.Read(); }
程序的运行结果为：
说明：在获取两个数相除的余数时,也可以用Math类的DivRem()方法来实现，如上述代码中的resut = numl % num2可以写成Math.DivRem(num1,num2,out resut)，result中存储了num1和num2的余数。
闯关训练：根据4.2.1节所学知识，制作一个简易的计算器程序,可以实现两个数的加、减、乘、除运算。
6. 数值类型和无穷大
C#语言的数字还有另两个特性是你必须了解的。例如，任何数除以0所得的结果是无穷大，超出了int，long和decimal类型的范围。所以，计算5/0这样的表达式会出错，但double和float类型实际上有一个可以表示无穷大的特殊值，因此表达式5.0/0.0的值是Infinity(无穷大)。该规则唯一的例外是表达式0.0/0.0。通常，如果0除以任何数，结果都是0，但任何数除以0结果是无穷大。表达式0.0/0.0会陷入一种自相矛盾的境地：值既是0，又是无穷大。针对这种情况，C#语言提供了另一个值NaN，即“not anumber”。所以，如果计算表达式0.0/0.0，则结果为NaN。NaN和Infinity可在表达式中使用。计算10+NaN，结果是NaN。计算10+Infinity，结果是Infinity。规则唯一的例外是Infinity*0，结果是0。而NaN*0的结果仍是NaN。
4.2.2 赋值运算符
赋值运算符为变量、属性、事件等元素赋新值。赋值运算符主要有：“=”“+=”“-=”“*=”“/=”“%=”“&="“|=”“^=”“<<=”和“>>=”运算符。赋值运算符的左操作数必须是变量、属性访问、索引器访问或事件访问类型的表达式，如果赋值运算符两边的操作数的类型不一致，就需要首先进行类型转换，然后再赋值。
在使用赋值运算符时，右操作数表达式所属的类型必须可隐式转换为左操作数所属的类型，运算将右操作数的值赋给左操作数指定的变量、属性或索引器元素。C#中的赋值运算符及其运算规则如表4.2所示。
|
表4.2 C#中的赋值运算符及其运算规则 |
|||
|
名称 |
运算符 |
运算规则 |
意义 |
|
赋值 |
= |
将表达式赋值给变量 |
将右边的值给左边 |
|
加赋值 |
+= |
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 |
下面以加赋值（+=）运算符为例，举例说明赋值运算符的用法。
[例4.7]创建一个控制台应用程序，声明一个int类型的变量i,并初始化为927。然后通过加赋值运算符改变i的值，使其在原有的基础上增加112,代码如下。
static void Main(string[] args) { int i = 927;//声明一个int类型的变量i并初始化为927 i += 112;//使用加赋值运算符 Console.WriteLine("最后i的值为：{0}", i);//输出最后变量i的值 Console.ReadLine(); }
程序的运行结果为：
说明：在C#中可以把赋值运算符连在一起使用。如：
x=y=z=5;
在这个语句中，变量x、y. z都得到同样的值5，但在程序开发中不建议使用这种赋值语法。
4.2.3 关系运算符
关系运算符属于二元运算符，用于程序中的变量之间、变量和自变量之间以及其他类型的信息之间的比较，它返回一个代表运算结果的布尔值。当运算符对应的关系成立时，运算结果为true，否则为false。所有关系运算符通常用在条件语句中来作为判断的依据。C#中的关系运算符共有6个，如表4.3 所示。
|
表4.3关系运算符 |
||||
|
运算符 |
作用 |
举例 |
操作数据 |
结果 |
|
> |
比较左方是否大于右方 |
‘a’>‘b’ |
整型、浮点型、字符型 |
false |
|
< |
比较左方是否小于右方 |
156<456 |
整型、浮点型、字符型 |
true |
|
== |
比较左方是否等于右方 |
‘c’==‘c’ |
基本数据类型、引用型 |
true |
|
>= |
比较左方是否大于或等于右方 |
479>=426 |
整型、浮点型、字符型 |
true |
|
<= |
比较左方是否小于或等于右方 |
12.45<=45.5 |
整型、浮点型、字符型 |
true |
|
!= |
比较左方是否不等于右方 |
‘y’!=‘t’ |
基本数据类型、引用型 |
true |
关系运算符就好像对两个铁球进行比较，看看这两个铁球哪个大，重量是否相等，并给出一个“ 真”或“假”的值。
下面对这几种关系运算符进行详细讲解。
1. 相等运算符
要查看两个表达式是否相等，可以使用相等运算符（==）。相等运算符对整型、浮点型和枚举类型数据的操作是一样的。 它只简单地比较两个表达式，并返回一个布尔结果。
[例4.8]创建一个控制台应用程序，声明两个decimal类型变量num1和num2，并分别赋值为1981.00m和1982.00m，然后再声明一个bool类型变量result，使其值等于num1和num2进行相等运算后的返回值，代码如下。
static void Main(string[] args) { decimal num1 = 1981.00m;//声明decimal类型变量num1 decimal num2 = 1982.00m;//声明decimal类型变量num2 bool result;//声明bool类型变量result result = num1 == num2;//使result等于num1和num2进行相等运算后的返回值 Console.WriteLine(result);//输出运行结果 Console.ReadLine(); }
程序的运行结果为：
2. 不等运算符
不等运算符（!=）是与相等运算符相反的运算符，有两种格式的不等运算符可以应用到表达式，一种是普通的不等运算符（!=）；另一种是相等运算符的否定“!(a==b)”。 通常，这两种格式可以计算出相同的值。
[例4.9]创建一个控制台应用程序， 声明两个decimal类型变量num1和num2,并分别赋值为1981.00m和1982.00m,然后再声明两个bool类型变量result和result1，使它们的值分别等于两种不等运算返回的值，代码如下。
static void Main(string[] args) { decimal num1 = 1981.00m;//声明decimal类型变量num1 decimal num2 = 1982.00m;//声明decimal类型变量num2 bool result;//声明bool类型变量result bool result1;//声明bool 类型变量result1 result = num1 != num2;//获取不等运算返回值第一种方法 result1 = !(num1 == num2);//获取不等运算返回值第二种方法 Console.WriteLine(result);//输出结果 Console.WriteLine(result1);//输出结果 Console.ReadLine(); }
程序的运行结果为：
3. 小于运算符
如果要比较一个值是否小于另一个值，可以使用小于运算符（<）。当左边的表达式的值小于右边表达式的值时，结果是真；否则，结果是假。
[例4.10]创建一个控制台应用程序，声明两个整型变量num1和num2,并分别赋值为1112和927，再声明一个bool类型变量result，使其值等于num1和num2进行小于运算的返回值，代码如下。
static void Main(string[] args) { int num1 = 1112;//声明整型变量num1 int num2 = 927;//声明整型变量num2 bool result;//声明bool类型变量result result = num1 < num2;//使result等于num1和num2进行小于运算的返回值 Console.WriteLine(result);//输出结果 Console.ReadLine(); }
程序的运行结果为：
说明：在用小于或大于运算符对值进行判断时，如果把判断符左右两边的值进行调换，其判断的结果也会随之改变。
4. 大于运算符
如果比较一个值是否大于另一个值，可以使用大于运算符（>）。当左边的表达式的值大于右边的表达式的值时，结果是真；否则，结果是假。
[例4.11]创建一个控制台应用程序，声明两个整型变量numl和num2,并分别赋值为18和8,再声明一个bool类型变量result,使其值等于num1和num2进行大于运算的返回值,代码如下。
static void Main(string[] args) { int num1 = 18;//声明整型变量num1 int num2 = 8;//声明整型变量num2 bool result;//声明bool类型变量result result = num1 > num2;//使result等于num1和num2进行大于运算的返回值 Console.WriteLine(result);//输出结果 Console.ReadLine(); }
程序的运行结果为：
5. 小于或等于运算符
如果要比较一个值是否小于或等于另一个值，可以使用小于或等于运算符（<=）。当左边表达式的值小于或等于右边表达式的值时，结果是真；否则，结果是假。
[例4.12]创建一个控制台应用程序,声明两个整型变量num1和num2,并分别赋值为12和9,然后再声明一个bool类型变量result,使其值等于numl和num2进行小于或等于运算的返回值，代码如下。
static void Main(string[] args) { int num1 = 12;//声明整型变量num1 int num2 = 9;//声明整型变量num2 bool result;//声明bool类型变量result result = num2 <= num1; //使result等于num1和num2进行小于或等于运算的返回值 Console.WriteLine(result);//输出结果 Console.ReadLine(); }
程序的运行结果为：
6. 大于或等于运算符
大于或等于运算符（>=）用于查看某个值是否大于或等于另一个值。当运算符左边表达式的值大于或等于右边表达式的值时，结果是真；否则，结果是假。
[例4.13]创建一个控制台应用程序，声明两个整型变量numl和num2,并分别赋值为1112和927，再声明一个bool类型变量resut,使其值等于num1和num2进行大于或等于运算的返回值，代码如下。
static void Main(string[] args) { int num1 = 1112;//声明整型变量num1 int num2 = 927;//声明整型变量num2 bool result;//声明bool类型变量result result = num2 >= num1; //使result等于num1和num2进行大于或等于运算的返回值 Console.WriteLine(result);//输出结果 Console.ReadLine(); }
程序的运行结果为：
说明：关系运算符一般常用于判断或循环语句中。
4.2.4 逻辑运算符
返回类型为布尔值的表达式，如关系运算符，可以被组合在一起构成一个更复杂的表达式，这是通过逻辑运算符来实现的。C#中的逻辑运算符主要包括“&（&&）（逻辑与）”“|（||）（逻辑或）”“!（逻辑非）”。逻辑运算符的操作元必须是bool型数据。在逻辑运算符中，除了“!”是一元运算符之外，其他都是二元运算符。表4.4给出了逻辑运算符的用法和含义。
|
表4.4逻辑运算符的用法和含义 |
|||
|
运算符 |
含义 |
用法 |
结合方向 |
|
&&、& |
逻辑与 |
op1&&op2 |
左到右 |
|
||、| |
逻辑或 |
op1||op2 |
左到右 |
|
! |
逻辑非 |
!op |
右到左 |
结果为bool类型的变量或表达式可以通过逻辑运算符组合为逻辑表达式。
用逻辑运算符进行逻辑运算时，结果如表4.5所示。
|
表4.5使用逻辑运算符进行逻辑运算 |
||||
|
表达式1 |
表达式2 |
表达式1&&表达式2 |
表达式1||表达式2 |
!表达式1 |
|
true |
true |
true |
true |
false |
|
true |
false |
false |
true |
false |
|
false |
false |
false |
false |
true |
|
false |
true |
false |
true |
true |
逻辑运算符“&&”与“&”都表示“逻辑与”，那么它们之间的区别在哪里呢？从表4.5可以看出，当两个表达式都为true时，逻辑与的结果才会是true。使用逻辑运算符“&”会判断两个表达式；而逻辑运算符“&&”则是针对bool类型的类进行判断，当第一个表达式为false时则不去判断第二个表达式，直接输出结果从而节省计算机判断的次数。通常将这种在逻辑表达式中从左端的表达式可推断出整个表达式的值称为“短路”，而那些始终执行逻辑运算符两边的表达式称为“非短路”。“&&”属于“短路”运算符，而“&”则属于“非短路”运算符。“||”与“|”的区别跟“&&”与“&”的区别类似。
[例4.14]创建一个控制台应用程序，在Main()方法中创建整型变量，使用逻辑运算符对变量进行运算，并将运算结果输出。
static void Main(string[] args) { int a = 2;//声明int型变量a int b = 5;//声明int型变量b bool result = ((a > b) && (a != b));//声明boolean型变量，用于保存应用逻辑运算符“&&”后的返回值 bool result2 = ((a > b) || (a != b));//声明boolean型变量，用于保存应用逻辑运算符“||”后的返回值 Console.WriteLine(result);//将变量result输出 Console.WriteLine(result2);//将变量result2输出 }
程序的运行结果为：
4.2.5 位运算符
位运算符除按位与、按位或运算符外，其他只能用于处理整数的操作数。位运算是完全针对位方面的操作。整型数据在内存中以二进制的形式表示，如int型变量7的二进制表示是00000000 00000000 00000000 00000111。
左边最高位是符号位，最高位是0表示正数，若为1则表示负数。负数采用补码表示，如1-8 的二进制表示为11111111 11111111 11111111 11111000这样就可以对整型数据进行按位运算。
1. “按位与”运算
“按位与”运算的运算符为“&”，“按位与”运算的运算法则是：如果两个整型数据a、b对应位都是1，则结果位才是1；否则结果为0。如果两个操作数的精度不同，则结果的精度与精度高的操作数相同，如图4.1所示。
2. “按位或”运算
“按位或”运算的运算符为“|”, “按位或”运算的运算法则是：如果两个操作数对应位都是0,则结果位才是0；否则结果为1。如果两个操作数的精度不同，则结果的精度与精度高的操作数相同，如图4.2所示。
3. “按位取反”运算
“按位取反”运算也称“按位非”运算，运算符为“~”,为一元运算符。“按位取反”就是将操作数二进制中的1修改为0，0修改为1，如图4.3所示。
4. “按位异或”运算
“按位异或”运算的运算符是“^”，“按位异或”运算的运算法则是：当两个操作数的二进制表示相同（同时为0或同时为1）时，结果为0；否则结果为1。若两个操作数的精度不同，则结果数的精度与精度高的操作数相同，如图4.4所示。
5. 移位操作
除了上述位运算符之外,还可以对数据按二进制位进行移位操作。C#中的移位运算符有以下两种。
<<：左移。
>>：右移。
对于X<<N或X>>N形式的运算，含义是将X向左或向右移动N位，得到的结果的类型与X相同。在此处，X的类型只能是int、uint、long或ulong，N的类型只能是int,或者显示转换为这些类型之一，否则编译程序时会出现错误。具体执行时，左移就是将左边的操作数在内存中的二进制数据左移右边操作数指定的位数，右边移空的部分补0。右移则复杂一些。 当使用“>>”运算符时，如果最高位是0,左移空的位就填入0；如果最高位是1,左移空的位就填入1,如图4.5所示。
移位可以实现整数除以或乘以2的n次方的效果。例如，y<<2与y*4的结果相同； y>>l 的结果与y/2的结果相同。总之，一个数左移n位，就是将这个数乘以2的n次方；一个数右移n位，就是将这个数除以2的n次方。
[例4.15]创建一个控制台应用程序,使变量intmax向左移位8次,并输出结果，代码如下。
static void Main(string[] args) { uint intmax = 8;//声明uint类型变量intmax uint bytemask;//声明uint类型变量bytemask bytemask = intmax << 8;//使intmax左移8次 Console.WriteLine(bytemask);//输出结果 Console.ReadLine(); }
程序的运行结果为：
4.2.6 其他特殊运算符
C#中还有一些运算符不能简单地归到某个类型中，下面对这些特殊的运算符进行详细讲解。
1. is运算符
is运算符用于检查变量是否为指定的类型。如果是，返回真；否则，返回假。
[例4.16]创建一个控制台应用程序，判断整型变量i是否为整型，可以通过下面的代码进行判断，代码如下。
static void Main(string[] args) { int i = 0;//声明整型变量i bool result = i is int;//判断i是否为整型 Console.WriteLine(result);//输出结果 Console.ReadLine(); }
因为i是整型，所以运行程序返回值为：
注意：不能重载is运算符。is运算符只考虑引用转换、装箱转换和取消装箱转换。不考虑其他转换，如用户定义的转换。
2. 条件运算符
条件运算符（?:）根据布尔型表达式的值返回两个值中的一个。如果条件为true, 则计算第一个表达式并以它的计算结果为准；如果为false, 则计算第二个表达式并以它的计算结果为准。使用格式为：
条件式?值1:值2
[例4.17]创建一个控制台应用程序,判断用户输入的年份是不是闰年，代码如下。
static void Main(string[] args) { Console.Write("请输入一个年份：");//屏幕输入提示字符串 string str = Console.ReadLine();//获取用户输入的年份 int year = Int32.Parse(str);//将输入的年份转换成int类型 //计算输入的年份是否为闰年 bool isleapyear = ((year % 400) == 0) || (((year % 4) == 0) && ((year % 100) != 0)); //利用条件运算符输入“是”或者“不是” string yesno = isleapyear ? "是" : "不是"; Console.WriteLine("{0}年{1}闰年", year, yesno);//输出结果 Console.ReadLine(); }
程序的运行结果为：
3. new运算符
new运算符用于创建一个新的类型实例，它有以下3种形式。
对象创建表达式，用于创建一个类类型或值类型的实例。
数组创建表达式，用于创建一个数组类型实例。
代表创建表达式，用于创建一个新的代表类型实例。
[例4.18]创建一个控制台应用程序，使用new运算符创建一个数组，向数组中添加项目，然后输出数组中的项，代码如下。
static void Main(string[] args) { string[] phone = new string[5];//创建具有5个项目的string类型数组 phone[0] = "华为P30";//为数组第一项赋值 phone[1] = "荣耀V20";//为数组第二项赋值 phone[2] = "小米9";//为数组第三项赋值 phone[3] = "VIVO X23";//为数组第四项赋值 phone[4] = "OPPO R17";//为数组第五项赋值 Console.WriteLine(phone[0]);//输出数组第-项 Console.WriteLine(phone[1]);//输出数组第二项 Console.WriteLine(phone[2]);//输出数组第三项 Console.WriteLine(phone[3]);//输出数组第四项 Console.WriteLine(phone[4]);//输出数组第五项 Console.ReadLine(); }
程序的运行结果为：
4. typeof运算符
typeof运算符用于获得系统原型对象的类型，也就是Type对象。Type类包含关于值类型和引用类型的信息。typeof运算符可以在C#语言中各种位置使用，以找出关于引用类型和值类型的信息。
[例4.19]创建一个控制台应用程序，利用typeof运算符获取引用整型的信息，并输出结果，代码如下。
static void Main(string[] args) { Type mytype = typeof(int);//获取int类型的原型对象 Console.WriteLine("类型：{0}", mytype);//输出结果 Console.ReadLine(); }
程序的运行结果为：
4.3 运算符优先级
C#中的表达式是使用运算符连接起来的符合C#规范的式子,运算符的优先级决定了表达式中运算执行的先后顺序。运算符优先级其实就相当于进销存的业务流程，如进货、入库、销售、出库，只能按这个步骤进行操作。运算符的优先级也是这样的，它是按照一定的级别进行计算的，通常优先级由高到低的顺序依次是：
◆增量和减量运算。
◆算术运算。
◆关系运算。
◆逻辑运算。
◆赋值运算。
如果两个运算符有相同的优先级，那么左边的表达式要比右边的表达式先被处理。在表达式中，可以通过括号“()”来调整运算符的运算顺序，将想要优先运算的运算符放置在括号“()” 内。当程序开始执行时，括号“()” 内的运算符会被优先执行。表4.6列出了所有运算符从高到低的优先级顺序。
|
表4.6运算符从高到低的优先级顺序 |
||
|
分类 |
运算符 |
优先级次序 |
|
基本 |
x.y、f(x)、a[x]、x++、x--、new、typeof、checked、unchecked |
高
低 |
|
一元 |
+、-、!、~、++x、--x、(T)x |
|
|
乘除 |
*、/、% |
|
|
加减 |
+、- |
|
|
移位 |
<<、>> |
|
|
比较 |
<、>、<=、>=、is、as |
|
|
相等 |
==、!= |
|
|
位与 |
& |
|
|
位异或 |
^ |
|
|
位或 |
| |
|
|
逻辑与 |
&& |
|
|
逻辑或 |
|| |
|
|
条件 |
?: |
|
|
赋值 |
=、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>= |
|
技巧：在编写程序时尽量使用括号“()”运算符来限定运算次序，以免产生错误的运算顺序。
4.4 小结
本章主要的内容是表达式与运算符，几种常用的运算符需要读者重点掌握。在应用程序开发中，运算符被频繁地使用，可见其重要性。常见的运算符有算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符以及其他一些特殊的运算符。如果表达式中需要同时存在几个运算符，那么就必须考虑运算符的优先级顺序，优先级顺序高的要比优先级顺序低的先被执行。
4.5 实践与练习
(1)尝试开发一个程序,要求用“+”运算符进行加法和串联字符串“15”。
(2)尝试开发一个程序,要求使用“?:”运算符对变量进行赋值。
(3)尝试开发一个程序,分别通过“++x"和“x++”运算符求和。