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# 编程指南)列表。

重点:

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

你可能感兴趣的:(c#,开发语言,后端)