C# C中抽象类中的重载运算符（如+；，-，*，/）#

我试图将类Vector实现为抽象类，并从中继承Vector2D和vector3D等内容。但是，我遇到了重写运算符的问题，因为它们要求返回静态对象引用，而我无法创建静态对象引用，因为我不允许在那里调用抽象类的构造函数

这是我想到的超控：

    public static Vector operator +(Vector v1, Vector v2)
    {
        if (v1.Dimension != v2.Dimension)
        {
            throw new Exception("Vector Dimensions Must Be Equal");
        }
        else
        {
            double[] newMatrix = new double[v1.Dimension]; //the matrix for the new (resulting) vector 
            for (int i = 0; i < v1.Dimension; i++)
            {
                newMatrix[i] = v1.Matrix[i] + v2.Matrix[i];
            }
            return new Vector(newMatrix);
            //the abstract class has a constructor that takes a matrix
            //and constructs a vector based on it, but it can't be called here
        }
    }

---

一个小小的免责声明我认为很重要：我在OOP方面还算不错，并且有一些经验，但是，我在一两周前就占领了C。因此，新秀的失误是意料之中的

让它成为一门具体的课程？我意识到这并不理想，但如果不可能……为什么不允许将Vector2D添加到Vector3D？为什么它们之间没有含蓄（或明确）的转换？这不是为了减损你问题的主旨，而是已经是一件事了，就像现在和将来一样。总的来说，它们根本不使用O-O概念（除了拥有实例的基础知识之外），因为这与高性能数字不太匹配（至少在C#中，有些语言可以更干净地结合这些概念）。一种选择是添加抽象保护的CreateInstance方法，哪个子类实现并返回其自身的新实例。但问题是，即使在调用两个Vector2D实例时，操作符也总是返回基向量。@JeroenMostert Fair point。在这种情况下，我的实现仍然是纯理论的。不管怎样，我这样做是为了锻炼。让它成为一门具体的课程？我意识到这并不理想，但如果不可能……为什么不允许将Vector2D添加到Vector3D？为什么它们之间没有含蓄（或明确）的转换？这不是为了减损你问题的主旨，而是已经是一件事了，就像现在和将来一样。总的来说，它们根本不使用O-O概念（除了拥有实例的基础知识之外），因为这与高性能数字不太匹配（至少在C#中，有些语言可以更干净地结合这些概念）。一种选择是添加抽象保护的CreateInstance方法，哪个子类实现并返回其自身的新实例。但问题是，即使在调用两个Vector2D实例时，操作符也总是返回基向量。@JeroenMostert Fair point。在这种情况下，我的实现仍然是纯理论的。无论如何，我这么做是为了锻炼身体。

using System;
using System.Text;

namespace PhysicsProblems
{
    public abstract class Vector
    {
        private static int IdCounter;

        protected readonly int ID;

        protected double[] Matrix;

        protected int Dimension
        {
            get
            {
                return Matrix.Length;
            }
        }

        public double Magnitude
        {
            get
            {
                double sum = 0;
                foreach (var value in Matrix)
                {
                    sum += value * value;
                }
                return Math.Sqrt(sum);
            }
        }

        public Vector(int dimension)
        {
            ID = IdCounter++;
            for (int i = 0; i < dimesion; i++)
            {
                Matrix[i] = 0;
            }
        }

        public Vector(double[] matrix)
        {
            ID = IdCounter++;
            matrix.CopyTo(Matrix, 0);
        }

        public static Vector operator +(Vector v1)
        {
            return v1;//to fix
        }
        public static Vector operator -(Vector v1)
        {
            for (int i = 0; i < v1.Matrix.Length; i++)
            {
                v1.Matrix[i] = -v1.Matrix[i];
            }
            return v1;//to fix
        }
        public static Vector operator +(Vector v1, Vector v2)
        {
            if (v1.Dimension != v2.Dimension)
            {
                throw new Exception("Vector Dimensions Must Be Equal");
            }
            else
            {
                double[] newMatrix = new double[v1.Dimension]; //the matrix for the new (resulting) vector 
                for (int i = 0; i < v1.Dimension; i++)
                {
                    newMatrix[i] = v1.Matrix[i] + v2.Matrix[i];
                }
                return new Vector(newMatrix);
                //the abstract class has a constructor that takes a matrix
                //and constructs a vector based on it, but it can't be called here
            }
        }

        public bool Equals(Vector vector)
        {
            if (vector.Dimension != Dimension) return false;

            bool check = true;
            for (int i = 0; i < Matrix.Length; i++)
            {
                if (vector.Matrix[i] != Matrix[i]) check = false;
            }
            return check;
        }

        public override bool Equals(object obj)
        {
            return Equals(obj as Vector);
        }

        public override int GetHashCode()
        {
            unchecked
            {
                int hash = 19;
                hash = (hash * 486187739) + ID.GetHashCode();
                hash = (hash * 486187739) + Dimension.GetHashCode();
                return hash;
            }
        }

        public override string ToString()
        {
            if (Dimension < 4)
            {
                var stringBuilder = new StringBuilder();
                for (int i = 0; i < Dimension; i++)
                {
                    stringBuilder
                        .Append(Constants.AxisLetters[i])
                        .Append(": ")
                        .Append(Matrix[i]);
                    if (i != Dimension - 1) stringBuilder.Append(", ");
                }
                return stringBuilder.ToString();
            }
            else
            {
                throw new NotImplementedException();
            }
        }
    }
}

using System;
using System.Text;

namespace PhysicsProblems
{
    public class Vector2D : Vector
    {

        public double X
        {
            get { return Matrix[0]; }
            set { Matrix[0] = value; }
        }

        public double Y
        {
            get { return Matrix[1]; }
            set { Matrix[1] = value; }
        }

        public Vector2D(int dimension) : base(dimension)
        { }
        public Vector2D(double[] matrix) : base(matrix)
        { }
    }
}