全面理解C#中的重载运算符和转换运算符

关于重载运算符大家可能都很少用，也就对他不是很理解了。
大家很少用的原因其中一个是因为写程序的时候都是用dataset datatable来保存数据，并没有构建自己的数据类，这样实现功能起来虽然很方便，但是灵活度就不够了，一直就限制在线性表的操作。2005年以前我也是这样做的，因为那时候我觉的dataset很方便，很好用，但是用久了就觉得，怎么C#就是dataset datagrid 。直到深入的去看petshop的代码，才理解了程序是什么，什么是架构。但是petshop是一个microsoft展示他C#的功能，所以有些功能对于实际开发并不太适用。

很多人会到论坛上问　　ClassA + ClassB 为什么会报错，结构都一样，为什么会错，microsoft怎么那么笨。
原因就在这里了，你应该告诉C# 你要怎么加，重载运算符就是告诉他，+ 法是这样做地。。。下面是我写的一个重载运算符+的一个例子 

 

public   class  MyClass
     ... {
        private int _x = 0;
        /**//// <summary>
        /// X属性
        /// </summary>
        public int X
        ...{
            get ...{ return _x; }
            set ...{ _x = value; }
        }

        private int _y = 0;
        /**//// <summary>
        /// Y属性
        /// </summary>
        public int Y
        ...{
            get ...{ return _y; }
            set ...{ _y = value; }
        }

        /**//// <summary>
        /// 重载+运算符号，让两个对象可以进行加操作
        /// </summary>
        /// <param name="A">加 对象</param>
        /// <param name="B">被加 对象</param>
        /// <returns>结果对象</returns>
        public static MyClass operator +(MyClass A, MyClass B)
        ...{
            MyClass resultClass = new MyClass();
            resultClass.X = A.X + B.X;
            resultClass.Y = A.Y + B.Y;
            return resultClass;
        }

    }

 

测试代码

 

  MyClass classA  =   new  MyClass( 10 ,  20 );
            MyClass classB  =   new  MyClass( 1 , 2 );
            MyClass classC  =  classA  +  classB;


            MessageBox.Show(classC.X.ToString());

            MessageBox.Show(classC.Y.ToString());

我们可以得到11 和12 两个结果，这样就可以对自定义类进行加法运算了。需要注意的是 重载运算符的定义 基本可以用于单、双目运算符，逻辑运算符不能重载(&&,||) 赋值运算符不能重载(+=,-=...)

public static MyClass operator + 的定义必须是static的，不能为其他定义.方法必须命名 operator 符号

关于转换运算符 是自定义类互相转换时非常重要的的一个功能。打个不恰当的比方：一个类是男孩，一个类是男人，怎么样把男孩转成男人呢。。。

转换运算符的定义与重载运算符的定义相似，下面给出转换运算符的例子，延用上面的MyClass在，再定义一个MyBestClass,建立转换运算符 ，实现MyClass到MyBestClass的转换

 

public   class  MyBestClass
     ... {
        private float _width;

        public float Width
        ...{
            get ...{ return _width; }
            set ...{ _width = value; }
        }


        private float _height;

        public float Height
        ...{
            get ...{ return _height; }
            set ...{ _height = value; }
        }

       　/**//// <summary>
        /// 显性转换运算符
        /// </summary>
        /// <param name="ClassA"></param>
        /// <returns></returns>
        public static explicit operator MyBestClass(MyClass ClassA)
        ...{
            MyBestClass BestClass = new MyBestClass();
            BestClass.Width = Convert.ToSingle(ClassA.X);
            BestClass.Height = Convert.ToSingle(ClassA.Y);
            return BestClass;
        }
    }

 

测试代码如下

MyClass classA  =   new  MyClass( 10 ,  20 );

            MyBestClass BestClass  =  (MyBestClass)classA;

            MessageBox.Show(BestClass.Width.ToString());
            MessageBox .Show (BestClass .Height .ToString ());

结果是10,20
static是必须的 ，operator 名字也是固定的，可变只有explicit
explicit表示显式转换，如其意思一样，操作的时候程序员明显知道这个类被转换了.
还有一个种是 隐式转换 implicit
如果

 

public   static   explicit   operator  MyBestClass(MyClass ClassA)

改为

public   static   implicit   operator  MyBestClass(MyClass ClassA)

那么

MyBestClass BestClass  =  (MyBestClass)classA;

就可以改为

MyBestClass BestClass  =  classA;         // 隐式转换 感觉不到类被转换了

实际运用来说，显式运算符更有用，因为更明显，可以让程序员引起一定的关注。

上面就是我对重载运算符和转换运算符的一些个人理解，如果偏差，大家不要砸我臭鸡蛋，直接扔烧鸡好了，希望对大家有点帮助