-2

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

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

3 回答 3

2

一点代码审查，这里有一些大的危险信号。

这个构造函数是危险的错误：

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

解决这两个（可能还有更多）问题的方法是将此类重新设计为不可变的。对于初学者，请从索引器中删除设置器。

这个运算符非常可疑，您的用例是什么：

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

它表明 Vector 不知何故是一个长度，实际上它只是有一个长度。

于 2012-10-10T19:27:15.413 回答
2

运算符重载非常简单，根据提供的代码，您似乎理解它。您可能会在这里遇到问题，例如：

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

您正在使用运算符本身定义 * 运算符，这是毫无意义的，并且可能无论如何都不起作用（将 Double d 乘以 Vector v 可能会起作用，但您已经在使用该功能）。

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

于 2012-10-10T19:30:41.593 回答
1

在 C# 中，所有项目都是对象，所以都在对象类中。

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

所以所有对象都至少有从 Object 继承的方法。如果您覆盖任何此函数（如 ToString），则基类上可用函数的实现将被您的实现替换。

对于操作符也是同样的情况，而且两个数组（或者你定义的其他类型）的操作符 + 不存在，所以它们应该有你的实现。

运算符与方法类似 static public Boolean operator ==(Vector v1, Vector v2)

需要 2 个向量项并返回一个布尔值等价于（不是在语法上）： Boolean Equal(Vector v1, Vector v2)

其余的方法相同。

我希望我是有帮助的。

于 2012-10-10T19:38:22.720 回答