C#学习笔记 ----运算符和强制类型转换（第7章）

运算符

算术运算符　　+- */%

逻辑运算符　　& | ^ ~ && || !

字符串连接运算符　　+

增量和减量运算符　　++ --

移位运算符　　<< >>

比较运算符　　== != <> <= >=

赋值运算符　　= += -= *= /= %= &= |= ^= <<= >>=

成员访问运算符　　.

索引运算符　　[]

类型转换运算符　　()

条件运算符（三元运算符）　　?:

委托连接和删除运算符　　+ -

对象创建运算符　　new

类型信息运算符　　sizeof is typeof as

溢出异常控制运算符　　checked unchecked

间接寻址运算符　　[]

名称空间别名限定符　　::

空合并运算符　　??

 

简化赋值运算符

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

int x=5;
if(++x == 6)//true ----x is incremented to 6 before the evaluation
{
    Console.WriteLine("This will execute");
}

if(x++ == 7)//false ----x is incremented to 7 after the evaluation
{
    Console.WriteLine("This won't");
}

 

代码块标记为checked，CLR就会执行溢出检查，如果发生溢出，就抛出OverflowException异常

byte b = 255;
checked
{
    b++;
}
Console.WriteLine(b.ToString());

禁止溢出检查，标记为unchecked

 

is运算符 可以检查对象是否与特定的类型兼容

int i = 10;
if (i is object)
{
    Console.WriteLine("i" is an object");
}

 

as运算符用于执行引用类型的显示类型转换

如果要转换的类型与制定的类型兼容，转换就会成功进行；如果类型不兼容，as运算符就会返回null值。

object o1 = "Some String";
object o2 = 5;
string s1 = o1 as string;//s1 = "Some String"
string s2 = o2 as string;//s2 = null;

 

sizeof运算符 可以确定栈中值类型需要的长度（单位是字节）

Console.WriteLine(sizeof(int));

 

typeof运算符 返回一个表示特定类型的System.Type对象

 

空合并运算符?? 提供了一种快捷方式，可以在处理可空类型和引用类型时表示null可能的值

 

在负责的表达式中，应避免利用运算符优先级来生成正确的结果。使用圆括号指定运算符的执行顺序，可以使代码整洁，避免出现潜在冲突。

 

隐式转换

只要保证值不会发生变化，类型转换就可以自动（隐式）进行

 

显示转换

类型强制转换

long val = 30000;
int i = (int)val; //A valid cast.The maximum int is 2147483647

所有预定义值类型都支持Parse()方法

 

装箱和拆箱可以把值类型转换为引用类型，并把引用类型转换为值类型

 

引用类型的相等性：ReferenceEquals() 和俩个版本的Equals()、比较运算符（==）

 

比较值类型相等性时，采用与引用类型相同的规则：ReferenceEquals()用于比较引用，Equals()用于比较值，比较运算符可以看作一个中间项

 

运算符重载

运算符重载的声明方式与方法相同，但operator关键字告诉编辑器，它实际上是一个自定义的运算符重载，后面是相关运算符的实际符号。

C#要求所有的运算符重载都声明为public 和static

struct Vector
{
public double x,y,z;

public Vector(double x,doubley,double z)
{
    this.x = x;
    this.y = y;
    this.z = z;
}

public Vector(Vector rhs)
{
    x = rhs.x;
    y = rhs.y;
    z = rhs.z;
}

public override string ToString()
{
    return "("+x+","+y+","+z+")";
}

public static Vector operator +(Vector lhs,Vector rhs)
{
    Vector result = new Vector(lhs);
    result.x += rhs.x;
    result.y += rhs.y;
    result.z += rhs.z;

    return result;
}

//测试Vector结构

static void Main()
{
    Vector vect1,vect2,vect3;
    vect1 = new Vector(3.0,3.0,1.0);
    vect2 = new Vector(2.0,-4.0,-4.0);
    vect3 = vect1 +vect2;

    Console.WriteLine("vect1 = " + vect1.ToString());
    Console.WriteLine("vect2 = " + vect2.ToString());
    Console.WriteLine("vect3 = " + vect3.ToString());
}

 

C#语言要求成对重载比较运算符。即，如果重载了“==”，就必须重载“!=”

 

用户定义的强制类型转换

C#允许进行俩种不同数据类型的强制转换：隐式强制转换和显式强制转换

类型强制转换必须同时声明为public 和static

 

struct Currency
{
    public uint Dollars;
    public ushort Cents;
    
    public Currency(uint dollars,ushort cents)
    {
        this.Dollars = dollars;
        this.Cents = cents;
    }
    public override string ToString()
    {
        return string.Format("${0}.{1,-2:00}",Dollars,Cents);
    }    
    //隐式
    public static implicit operator float(Currency value)
    {
        return value.Dollars + (value.Cents/100.0f);
    }
    //显式
    public static explicit operator Currency(float value)
    {
        checked
        {
            uint dollars = (uint)value;
            ushort cents = (ushort)((value - dollars)*100);
            return new Currency(dollars,cents);
        }
    }
}

 

定义不同结构或类的实例之间的类型强制转换是完全合法的，但有俩个限制：

.如果某个类派生自另一个类，就不能定义这俩个类之间的类型强制转换（这些类型的类型转换已经存在）

.类型强制转换必须在源数据类型或目标数据类型的内部定义

 

装箱和拆箱数据类型强制转换

 

多重类型强制转换