Question

我犯了一个错误，我发布了我的代码，它表明我很懒，我只想要为我完成所有事情，我想在下面的代码中了解运算符重载以及此代码在主程序

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

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

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

Answer 1

一些代码审查，这里有一些大红旗。

这个构造函数是非常错误的：

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

elements是一个引用（对于数组），因此您在此处创建2个Vector对象，共享相同的元素。

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

对这两个（可能还有一些）问题的补救措施是重新设计这个类是不可变的。对于初学者，请从索引器中删除setter。

这个操作符非常可疑，你的用例是什么：

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

它表明Vector以某种方式是一个长度，实际上它只是具有长度。

Answer 2

运算符重载非常简单，根据提供的代码，看起来就像你理解它一样。您可能遇到的问题是，例如：

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

你用运算符本身定义*运算符，这是毫无意义的，可能无论如何都不会起作用（将Double d乘以Vector v可能有效，但你已经使用了这个功能）。

如果您了解函数，运算符会使用两个参数执行相同的操作并返回您想要的值。

Answer 3

在C＃中，所有项都是对象，因此所有内容都是Object Class。

http://msdn.microsoft.com/en-us/library/system.object.aspx

因此，所有对象至少都有来自Object的方法。如果你覆盖任何像ToString这样的函数，基类上可用的函数的实现将被你的实现替换。

对于运算符是相同的情况，而且运算符+对于两个数组（或由您定义的其他类型）不存在，因此它们应该有您的实现。

运算符与方法类似 static public Boolean operator ==（Vector v1，Vector v2）

需要2个矢量项并返回一个布尔值等价（不是语法）与：布尔等于（向量v1，向量v2）

其他方法相同。

我希望我能提供帮助。

运算符重载如何在此代码中工作

3 个答案: