C# 关于运算符重载--矢量之间的运算

运算符重载就是指重写 1+1 = ？中的加号“+”，那样我们可以实现1 + 1 = 1。类似的，其他运算符重载也是这样的道理，然运算符的重载用来干这些事显得鸡肋了些，更多的是，通过运算符重载去实现一般的加减乘除不能实现的运算，例如：

——> 矢量的加减乘除？

    class Program
    {
        static void Main(string[] args)
        {
            Vector vect1, vect2, vect3, vect4;
            vect1 = new Vector(3.0, 2.0, 1.0);
            vect2 = new Vector(2.0, -4.0, -4.0);
            vect3 = vect1 + vect2;
            vect4 = new Vector(3.0, 2.0, 1.0);
            Console.WriteLine("Vect1 = {0}", vect1.ToString());
            Console.WriteLine("Vect2 = {0}", vect2.ToString());
            Console.WriteLine("Vect3 = {0}", vect3.ToString());
            Console.WriteLine("Vect1 == Vect4 {0}", vect1 == vect4);
            Console.ReadKey();
        }
    }

    /// <summary>
    /// 向量结构
    /// </summary>
    struct Vector
    {
        public double x, y, z;

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

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

        public override string ToString()
        {
            return "(" + x + ", " + y + ", " + z + ")";
        }
        /// <summary>
        /// 向量加法
        /// </summary>
        /// <param name="lhs"></param>
        /// <param name="rhs"></param>
        /// <returns></returns>
        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;
        }
        /// <summary>
        /// 向量点积
        /// </summary>
        /// <param name="lhs"></param>
        /// <param name="rhs"></param>
        /// <returns></returns>
        public static Vector operator *(double lhs, Vector rhs)
        {
            return new Vector(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z);
        }
        /// <summary>
        /// 向量点积
        /// </summary>
        /// <param name="lhs"></param>
        /// <param name="rhs"></param>
        /// <returns></returns>
        public static Vector operator *(Vector rhs, double lhs)
        {
            return lhs * rhs;
        }

        public static bool operator ==(Vector lhs, Vector rhs)
        {
            if (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z)
                return true;
            else
                return false;
        }

        public static bool operator !=(Vector lhs, Vector rhs)
        {
            if (lhs.x != rhs.x && lhs.x != rhs.y && lhs.z != rhs.z)
                return true;
            else
                return false;
        }
    }

以上两种比较方式存在问题：

1、如果某参数为null，则出现 null.Equals(obj) 的情况，会触发空引用异常

2、这样的比较无法确认只是值相等，不是指向同一个东西（值相等，地址不同），还是指向同一个（即值与地址都相等）

3、重载了“==”、“!=”运算符却没有没有实现Object.Equals(obj)方法（这里对本例来说，不是很重要，但应当知道程序的缺点在哪）

上述的“!=”、“==”比较方式仅根据矢量元素的值,来对它们进行相等性比较。对于大多数结构,这就是我们希望的,但在某些情况下,可能需要仔细考虑相等的含义。例如,如果有嵌入的类,那么是应比较引用 是否指向同一个对象(浅度比较),还是应比较对象的值是否相等(深度比较)?  浅度比较是比较对象是否指向内存中的同一个位置,而深度比较是比较对象的值和属性是否相等.