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

最新推荐文章于 2024-07-02 20:26:10 发布

〃Geek,

最新推荐文章于 2024-07-02 20:26:10 发布

阅读量1.1k

点赞数

文章标签： c# 开发语言后端

本文链接：https://blog.csdn.net/qq_53631528/article/details/121087308

版权

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

    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);
        }
    }

结构体和类的区别：

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

运算符的重载：

        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 )

参数说明：