C#类和结构体、运算符重载

• 对于类而言，两个变量指向同一个对象的情况是存在的，因此对这两个变量钟的任意一个进行操作，其结果必然会影响另一个值
• 对于结构体而言，直接包含它自己的数据，每个结构都保存自己的一份数据，修改每一个结构的数据都不会对其他结构的数据造成影响

    static void Main(string[] args)
        {
            Point p1 = new Point(1, 1);
            Point p2 = p1;
            p1.print();//1,1
            p2.print();//1,1

            p2.X = 10;
            p2.Y = 10;
            p2.print();//10,10
            p1.print();//1,1  改变p2的值，p1的值不受影响  值类型 结构体

            Console.WriteLine("------------------");
            CPoint P1 = new CPoint(1, 1);
            CPoint P2 = P1;
            P1.print();//1,1
            P2.print();//1,1

            P2.X = 10;
            P2.Y = 10;
            P2.print();//10,10
            P1.print();//10,10  改变p2的值，p1的值受影响  引用类型 类
        }
    struct Point//结构体
    {
        private float x;
        private float y;
        public Point(float _x, float _y)
        {
            x = _x;
            y = _y;
        }
        public float X
        {
            get { return x; }
            set { x = value; }
        }
        public float Y
        {
            get { return y; }
            set { y = value; }
        }
        public void print()
        {
            Console.WriteLine("{0},{1}",x,y);
        }
    }
    class CPoint//类
    {
        private float x;
        private float y;
        public CPoint(float _x, float _y)
        {
            x = _x;
            y = _y;
        }
        public float X
        {
            get { return x; }
            set { x = value; }
        }
        public float Y
        {
            get { return y; }
            set { y = value; }
        }
        public void print()
        {
            Console.WriteLine("{0},{1}", x, y);
        }
    }        

结构体和类的区别：

1. 结构体关键字是struct，类是class
2. 结构体不可以在声明时直接对字段初始化，而类可以
3. 结构体无论有没有声明构造函数，默认构造函数一直存在，而类中一旦声明构造函数，编译器都不再提供默认的构造函数
4. 结构体不能显式的声明无参的默认构造函数
5. 结构体中的构造函数必须为所有的字段初始化
6. 结构体不能被继承，也不能使用关键字abstract或sealed关键字
7. 结构体是值类型，类是引用类型
8. 结构体不能定义析构函数

运算符的重载：

        static void Main(string[] args)
        {
            point Q = new point(1, 1);
            point W = new point(2, 2);
            point E = Q + W;
            E.print();
        }
    class point
    {
        private float x;
        private float y;
        public point(float _x,float _y)
        {
            x = _x;
            y = _y;
        }
        public float A
        {
            get { return x; }
            set { x = value; }
        }
        public float B
        {
            get { return y; }
            set { y = value; }
        }
        public void print()
        {
            Console.WriteLine("{0},{1}",x,y);
        }
        //运算符重载
        public static point operator+(point Q1, point W1)
        {
            point P3 = new point(0, 0);
            P3.x = Q1.x + W1.x;
            P3.y = Q1.y + W1.y;
            return P3;
        }
    }        

C# 允许用户定义的类型通过使用 operator 关键字定义静态成员函数来重载运算符。

注意：必须用public修饰且必须是类的静态的方法。但并非所有内置运算符都可以被重载

        static void Main(string[] args)
        {
            point Q = new point(1, 1);
            point W = new point(2, 2);
            point E = Q + W;
            E.print();
        }
    class point
    {
        private float x;
        private float y;
        public point(float _x,float _y)
        {
            x = _x;
            y = _y;
        }
        public float A
        {
            get { return x; }
            set { x = value; }
        }
        public float B
        {
            get { return y; }
            set { y = value; }
        }
        public void print()
        {
            Console.WriteLine("{0},{1}",x,y);
        }
        //运算符重载
        public static point operator+(point Q1, point W1)
        {
            point P3 = new point(0, 0);
            P3.x = Q1.x + W1.x;
            P3.y = Q1.y + W1.y;
            return P3;
        }

    }        

运算符	                                    可重载性
 +、-、!、~、++、--、true、false	      可以重载这些一元运算符，true和false运算符必须成对重载
 +、-、*、/、%、&、|、^、<<、>>	      可以重载这些二元运算符
 ==、!=、<、>、<=、>=	              可以重载比较运算符，必须成对重载
 &&、||	                              不能重载条件逻辑运算符，但可以使用能够重载的&和|进行计算
 []	        不能重载数组索引运算符，但可以定义索引器
 ()	        不能重载转换运算符，但可以定义新的转换运算符（请参见 explicit 和 implicit）
 +=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=	    不能显式重载赋值运算符，在重写单个运算符如+、-、%时，它们会被  隐式重写
 =、.、?:、->、new、is、sizeof、typeof	    不能重载这些运算符

二、声明

operator 关键字用于在类或结构声明中声明运算符。运算符声明可以采用下列四种形式之一：

public static result-type operator unary-operator ( op-type operand )

public static result-type operator binary-operator ( op-type operand, op-type2 operand2 )

public static implicit operator conv-type-out ( conv-type-in operand )

public static explicit operator conv-type-out ( conv-type-in operand )

参数说明：

• result-type：运算符的结果类型。
• unary-operator：下列运算符之一：+ - ! ~ ++ — true false
• op-type：第一个（或唯一一个）参数的类型。
• operand：第一个（或唯一一个）参数的名称。
• binary-operator：其中一个：+ - * / % & | ^ << >> == != > < >= <=
• op-type2：第二个参数的类型。
• operand2：第二个参数的名称。
• conv-type-out：类型转换运算符的目标类型。
• conv-type-in：类型转换运算符的输入类型。

注意：

1、运算符重载的声明方式：operator 关键字告诉编译器，它实际上是一个运算符重载，后面是相关运算符的符号。

2、运算符只能采用值参数，不能采用ref或out参数。可参考注意事项一实例。

3、前两种形式声明了用户定义的重载内置运算符的运算符。op-type 和 op-type2 中至少有一个必须是封闭类型（即运算符所属的类型，或理解为自定义的类型）。例如，这将防止重定义整数加法运算符。可参考注意事项二实例。

4、后两种形式声明了转换运算符。conv-type-in 和 conv-type-out 中正好有一个必须是封闭类型（即转换运算符只能从它的封闭类型转换为其他某个类型，或从其他某个类型转换为它的封闭类型）。

5、对于二元运算符，第一个参数是放在运算符左边的值，一般命名为lhs；第二个参数是放在运算符右边的值，一般命名为rhs。

6、C#要求所有的运算符重载都声明为public和static，必须是类的静态方法，这表示它们与它们的类或结构相关联，而不是与实例相关联。

比较运算符的重载：

a、C#要求成对重载比较运算符，如果重载了==，也必须重载！=，否则会产生编译错误。

b、比较运算符必须返回bool类型的值，这是与其他算术运算符的根本区别。

c、在重载= =和! =时，还应该重载从System.Object中继承的Equals()和GetHashCode()方法，否则会产生一个编译警告，原因是Equals方法应执行与= =运算符相同的相等逻辑。

d、C# 不允许重载=运算符，但如果重载例如+运算符，编译器会自动使用+运算符的重载来执行+=运算符的操作。

e、任何运算符声明的前面都可以有一个可选的属性（C# 编程指南）列表。

重点：

运算符重载其实就是函数重载。首先通过指定的运算表达式调用对应的运算符函数，然后再将运算对象转化为运算符函数的实参，接着根据实参的类型来确定需要调用的函数的重载，这个过程是由编译器完成。