【重走C#之路】之运算符(二)

21.&&运算符

          条件“与”运算符(&&)执行其bool操作数的逻辑“与”运算，但仅在必要时才计算第二个操作数。操作：x&&y。

          如果x为false，则不计算y(因为无论y为何值，“与”操作的结果都为false)。这被称为“短路”计算。

          不能重载条件“与”运算符，但常规逻辑运算符和运算符true与false的重载，在某些限制条件下也被视为条件逻辑运算符的重载。

22.||运算符

          条件“或”运算符(||)执行bool操作数的逻辑“或”运算，但仅在必要时才计算第二个操作数。操作：x||y。

          如果x为true，则不计算y(因为不论y为何值，“或”操作的结果都为true)。这被称为“短路”计算。

          不能重载条件“或”运算符，但常规逻辑运算符和运算符true与false的重载，在某些限制条件下也被视为条件逻辑运算符的重载。

23.左移运算符

          左移运算符(<<)将第一个操作数向左移第二个操作数指定的位数。第二个操作数类型必须是int。

          如果第一个操作数是int或uint(32位数)，则移位数由第二个操作数的低5位给出。

          如果第一个操作数是long或ulong(64位)，则移位数由第二个操作数的低6位给出。

          第一操作数的高序位被放弃，低序位用0填充。移位操作从不导致溢出。

          用户定义的类型可重载<<运算符，第一个操作数必须为用户定义的类型，第二个操作数必须为int。重载二元运算符时，也会隐式重载相应的赋值运算符(如果有)。

代码

 1           using  System;
 2           class  MainClass
 3          {
 4               static   void  Main() 
 5              {
 6                   int  i  =   1 ;
 7                   long  lg  =   1 ;
 8                  Console.WriteLine( " 0x{0:x} " , i  <<   1 ); // 结果为：0x2
 9                  Console.WriteLine( " 0x{0:x} " , i  <<   33 ); // 结果为：0x2
10                  Console.WriteLine( " 0x{0:x} " , lg  <<   33 ); // 结果为：0x200000000
11              }
12          }

24.>>运算符

          右移运算符将第一个操作数向右移动第二个操作数所指定的位数。类似<<，不再详细介绍。

          如果第一个操作数为int或uint(32位数)，则移位数由第二个操作数的低五位给出(第二个操作数&0x1f)。

          如果第一个操作数为long或ulong(64位数)，则移位数有第二个操作数的低六位给出(第二个操作数&0x3f)。

          如果第一个操作数为int或long，则右移位是算术移位(高序空设置为符号位)。如果第一个操作数为uint或ulong，则右移位是逻辑移位(高位填充0)。

代码

1           using  System;
2           class  MainClass
3          {
4               static   void  Main() 
5              {
6                   int  i  =   - 1000 ;
7                  Console.WriteLine(i  >>   3 ); // 结果为：-125
8              }
9          }

25.==运算符

          对于预定义的值类型，如果操作数的值相等，则相等运算符返回true，否则返回false。对于string以外的应用类型，如果两个操作数引用同一个对象，则==返回true。对于string类型，==比较字符串的值。

代码

 1           using  System;
 2           class  MainClass
 3          {
 4               static   void  Main() 
 5              {
 6                  Console.WriteLine(( 2   +   2 )  ==   4 ); // 结果为：true
 7 
 8                   object  s  =   1 ;
 9                   object  t  =   1 ;
10                  Console.WriteLine(s  ==  t); // 引用类型，虽然值相同但不同对象，结果为:false
11 
12                   string  a  =   " hello " ;
13                   string  b  =  String.Copy(a);
14                   string  c  =   " hello " ; // 定义字符串                
15                  Console.WriteLine(a  ==  b); // 字符串只检查值，结果为：true
16 
17                  Console.WriteLine(( object )a  ==  ( object )b); // string以外的引用类型判断对象引用，false
18                  
19                  Console.WriteLine(( object )a  ==  ( object )c); // a,c都引用自"hello"，故结果为true
20              }
21          }

26.！=运算符

          如果操作数相等，则不等运算符(!=)返回false，否则返回true。为所有类型（包括字符串和对象）预定义了不等运算符。用户定义类型可重载！=运算符。

          对于预定义值类型，判断值，string以外的引用类型判断引用是否同一个对象，string类型则判断字符串的值。

27.<=运算符

          所有数值和枚举类型都定义了“小于等于”关系运算符（<=），如果第一个操作数小于或等于第二个操作数，则该运算符将返回true，否则返回false。用户定义的类型可重载<=运算符。

28.>=运算符

          所有数值类型和枚举类型都定义“大于等于”关系运算符>=，如果第一个操作数大于或等于第二个操作数，该运算符返回true，否则返回false。用户定义的类型可重载>=运算符。

29.+=运算符

          加法赋值运算符，使用+=赋值运算符的表达式，例如x+=y等效于x=x+y，不同的是x只计算一次。+运算符的含义取决于x和y的类型（对于数值操作数，其含义为相加；对于字符串操作数，其含义为串联）。不能直接重载+=运算符，但用户定义的类型可以重载+运算符。

          +=运算符还用于指定响应事件时要调用的方法，这类方法称为事件处理程序。因为事件处理程序封装在委托类型中，所以在此上下文中使用+=运算符称为“串联委托”。

30.-=运算符

          减法赋值运算符，使用-=赋值运算符的表达式如x-=y等效于x=x-y，不同的是x只计算一次。运算符的含义取决于x和y的类型（例如，对于数值操作数，其含义为相减；对于委托操作数，其含义为移除）。

31.*=运算符

          乘法赋值运算符，使用*=运算符的表达式x *= y等效于x = x * y，不同的是x只计算一次。

32./=运算符

          除法赋值运算符，使用/=运算符的表达式x  /= y等效于x = x / y，不同的是x只计算一次。

33.%/运算符

          模块赋值运算符，使用%=运算符的表达式x %= y等效于x = x% y，不同的是x只计算一次。

34.&=运算符

          “与”赋值运算符，使用&=运算符的表达式x &= y等效于x = x & y，不同的是x只计算一次。

35.|=运算符

          “或”赋值运算符，使用|=运算符的表达式x |= y等效于x = x | y，不同的是x只计算一次。

36.^=运算符

          “异或”赋值运算符，使用^=运算符的表达式x ^= y等效于x = x ^ y,不同的是x只计算一次。

37.<<=运算符

          左移赋值运算符,使用<<=运算符的表达式x <<= y等效于x = x << y，不同的是x只计算一次。

38.>>= 运算符

          右移赋值运算符,使用>>=运算符的表达式x >>= y等效于x = x >> y，不同的是x只计算一次。

39.->运算符

          ->运算符将指针取消引用或成员访问组合在一起。x->y（其中x为T*类型的指针，y为T的成员）等效于(*x).y

          ->运算符只能在非托管代码中使用，不能重载->运算符。

代码

 1           using  System;
 2           struct  Point
 3          {
 4               public   int  x, y; 
 5          }
 6 
 7           class  MainClass
 8          {
 9               unsafe   static   void  Main() 
10              {
11                  Point pt  =   new  Point();
12                  Point *  pp  =   & pt;
13                  pp -> x  =   123 ;
14                  pp -> y  =   456 ;
15                  Console.WriteLine (  " {0} {1} " , pt.x, pt.y ); // 结果为：123 456
16              }
17          }

 40.??运算符

          如果??运算符的左边操作数非空，该运算符将返回左操作数，否则返回右操作数。可空类型可以包含值，或者可以是未定义的。?? 运算符定义当可空类型分配给非可空类型时返回的默认值。如果在将可空类型分配给非可空类型时不使用 ?? 运算符，将生成编译时错误。如果使用强制转换，并且当前未定义可空类型，将发生 InvalidOperationException 异常。

代码

 1           using  System;
 2           class  MainClass
 3          {
 4               static   int ?  GetNullableInt()
 5              {
 6                   return   null ;
 7              }
 8 
 9               static   string  GetStringValue()
10              {
11                   return   null ;
12              }
13 
14               static   void  Main()
15              {
16                   int ?  x  =   null ; 
17                   int  y  =  x  ??   - 1 ;
18                   int  i  =  GetNullableInt()  ??   default ( int ); // 结果为：0
19                   string  s  =  GetStringValue();
20                  Console.WriteLine(s  ??   " Unspecified " ); // 结果为：Unspecified
21              }
22          }