C# 在这段代码中，运算符重载是如何工作的

我在发布代码时犯了一个错误，这表明我很懒，我只想为我做所有事情，我想了解下面代码中的运算符重载，以及这段代码在主程序中的作用

static public explicit operator Int32(Vector v)
        {
            return v.Length;
        }

        public override string ToString()
        {
            String res = "<";
            for (int i = 0; i < elements.Length; i++)
                res += " " + elements[i];
            res += " >";
            return res;
        }

        public override bool Equals(Object v)
        {
            return (this == (Vector)v);
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }

静态公共显式运算符Int32（向量v）
{
返回v.长度；
}
公共重写字符串ToString（）
{
字符串res=“”；
返回res；
}
公共覆盖布尔等于（对象v）
{
返回值（此==（向量）v）；
}
公共覆盖int GetHashCode（）
{
返回base.GetHashCode（）；
}
}

该代码通过重写向量的加法、减法、乘法运算和等式/不等式运算符来实现一类向量。考虑一个操作数-实数或整数的运算。在操作中维度向量重合的情况下引发异常

namespace ConsoleApplication3
{



    public class Vector
    {
        private Double[] elements;

        public Vector()
        {
            this.elements = null;
        }

        public Vector(Int32 size)
        {
            if (size < 0) throw new Exception("Invalid vetors size");        
            elements = new Double[size];
        }

        public Vector(params Double[] elements)
        {
            this.elements = elements;
        }

        public Vector(Vector v)
        {
            this.elements = v.elements;
        }

        public int Length
        {
            get
            {
                if (elements == null) return 0;
                return elements.Length;
            }
        }

        public Double this[int index]
        {
            get 
            {
                return elements[index];
            }
            set 
            {
                elements[index] = value;
            }
        }

        static public Vector operator+(Vector v1, Vector v2)
        {
            if (v1.Length != v2.Length)
                throw new Exception("size of vectors are different");
            Vector res = new Vector(v1.Length);
            for (int i = 0; i < res.Length; i++)
                res[i] = v1[i] + v2[i];
            return res;
        }

        static public Vector operator+(Vector v, Double d)
        {
            Vector res = new Vector(v.Length);
            for (int i = 0; i < v.Length; i++ )
                res[i] = v[i] + d;
            return res;
        }

        static public Vector operator +(Double d, Vector v)
        {
            return (v + d);
        }

        static public Vector operator -(Vector v, Double d)
        {
            Vector res = new Vector(v.Length);
            for (int i = 0; i < v.Length; i++)
                res[i] = v[i] - d;
            return res;
        }

        static public Vector operator -(Double d, Vector v)
        {
            Vector res = new Vector(v.Length);
            for (int i = 0; i < v.Length; i++)
                res[i] = d - v[i];
            return res;
        }

        static public Vector operator *(Vector v, Double d)
        {
            Vector res = new Vector(v.Length);
            for (int i = 0; i < v.Length; i++)
                res[i] = v[i] * d;
            return res;
        }

        static public Vector operator *(Double d, Vector v)
        {
            return (v * d);
        }

        static public Vector operator -(Vector v1, Vector v2)
        {
            if (v1.Length != v2.Length)
                throw new Exception("size of vectors are different");
            Vector res = new Vector(v1.Length);
            for (int i = 0; i < res.Length; i++)
                res[i] = v1[i] - v2[i];
            return res;
        }

        static public Vector operator *(Vector v1, Vector v2)
        {
            if (v1.Length != v2.Length)
                throw new Exception("size of vectors are different");
            Vector res = new Vector(v1.Length);
            for (int i = 0; i < res.Length; i++)
                res[i] = v1[i] * v2[i];
            return res;
        }

        static public Boolean operator ==(Vector v1, Vector v2)
        {
            if (v1.Length != v2.Length)
                return false;            
            for (int i = 0; i < v1.Length; i++)
                if(v1[i] != v2[i]) return false;
            return true;
        }

        static public Boolean operator !=(Vector v1, Vector v2)
        {
            return (!(v1 == v2));
        }

        static public explicit operator Int32(Vector v)
        {
            return v.Length;
        }

        public override string ToString()
        {
            String res = "<";
            for (int i = 0; i < elements.Length; i++)
                res += " " + elements[i];
            res += " >";
            return res;
        }

        public override bool Equals(Object v)
        {
            return (this == (Vector)v);
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Vector v1 = new Vector(new Double[]{1, 2, 3, 4});
            Vector v2 = new Vector(2, 3, 4, 5);
            Console.WriteLine(v1 + " + " + v2 + " = " + (v1 + v2));
            Console.WriteLine(v1 + " - " + v2 + " = " + (v1 - v2));
            Console.WriteLine(v1 + " * " + v2 + " = " + (v1 * v2));
            Console.WriteLine(v1 + " * " + 7 + " = " + (v1 * 7));
            Console.ReadKey(true);
        }
    }
}

命名空间控制台应用程序3
{
公共类向量
{
私人双[]要素；
公共向量（）
{
this.elements=null；
}
公共向量（Int32大小）
{
如果（大小<0）抛出新异常（“无效的审查者大小”）；
元素=新的双[大小]；
}
公共向量（参数双[]元素）
{
这个元素=元素；
}
公共向量（向量v）
{
此元素=v元素；
}
公共整数长度
{
得到
{
if（elements==null）返回0；
返回元素。长度；
}
}
公共双本[int索引]
{
得到
{
返回元素[索引]；
}
设置
{
元素[索引]=值；
}
}
静态公共向量运算符+（向量v1，向量v2）
{
如果（v1.Length！=v2.Length）
抛出新异常（“向量大小不同”）；
Vector res=新矢量（v1.长度）；
for（int i=0；i

一点代码回顾，这里有一些大的危险信号

此构造函数的错误非常危险：

    public Vector(Vector v)
    {
        this.elements = v.elements;
    }

elements

是一个引用（指向数组），因此您在此处创建了两个共享相同元素的向量对象

Vector v1 = new Vector(10);
Vector v2 = new Vector(v1);  // 2 vectors, 1 elements

v1[0] = 1.2;
Console.WriteLine(v2[0]);  // prints 1.2

出于同样的原因，这一次至少是危险的：

    public Vector(params Double[] elements)
    {
        this.elements = elements;
    }

解决这两个（可能还有更多）问题的一个方法是将这个类重新设计为不可变的。首先，将设定器从机器上拆下

    static public explicit operator Int32(Vector v)
    {
        return v.Length;
    }

static public Vector operator *(Double d, Vector v)
    {
        return (v * d);
    }