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)方法（這裏對本例來說，不是很重要，但應當知道程序的缺點在哪）

上述的“!=”、“==”比較方式僅根據矢量元素的值,來對它們進行相等性比較。對於大多數結構,這就是我們希望的,但在某些情況下,可能需要仔細考慮相等的含義。例如,如果有嵌入的類,那麼是應比較引用 是否指向同一個對象(淺度比較),還是應比較對象的值是否相等(深度比較)?  淺度比較是比較對象是否指向內存中的同一個位置,而深度比較是比較對象的值和屬性是否相等.