C#抽象类运算符重载

public abstract class Vector
{
    protected abstract Vector Add(Vector otherVector);

    public static Vector operator +(Vector v1,Vector v2)
    {
        return v1.Add(v2);
    }
}

public class SubVector : Vector
{
    protected override Vector Add(Vector otherVector)
    {
        //do some SubVector addition
    }
}

可能遇到一些问题,特别是有多个子类(SubVector必须知道如何添加SomeOtherSubVectorClass？如果你添加了ThirdVectorType类怎么办？)并且可能处理空案例.此外,确保SubVector.Add在进行交换操作时与SomeOtherSubVectorClass.Add的行为相同.

编辑：基于您的其他评论,你可以这样：

public class Vector2D : Vector
{
    public double X { get; set; }
    public double Y { get; set; }

    protected override Vector Add(Vector otherVector)
    {
        Vector2D otherVector2D = otherVector as Vector2D;
        if (otherVector2D != null)
            return new Vector2D() { X = this.X + otherVector2D.X,Y = this.Y + otherVector2D.Y };

        Vector3D otherVector3D = otherVector as Vector3D;
        if (otherVector3D != null)
            return new Vector3D() { X = this.X + otherVector3D.X,Y = this.Y + otherVector3D.Y,Z = otherVector3D.Z };

        //handle other cases
    }
}


public class Vector3D : Vector
{
    public double X { get; set; }
    public double Y { get; set; }
    public double Z { get; set; }

    protected override Vector Add(Vector otherVector)
    {
        Vector2D otherVector2D = otherVector as Vector2D;
        if (otherVector2D != null)
            return new Vector3D() { X = this.X + otherVector2D.X,Y = this.Y + otherVector2D.Y,Z = this.Z };

        Vector3D otherVector3D = otherVector as Vector3D;
        if (otherVector3D != null)
            return new Vector3D() { X = this.X + otherVector3D.X,Z = this.Z + otherVector3D.Z };

        //handle other cases
    }
}

EDITx2：

鉴于您的最新评论,也许您应该只维护一个内部数组/矩阵,只做通用矩阵数学.您的子类可以针对数组指示公开X / Y / Z属性包装器：

public class Vector
{
    protected double[] Values;
    public int Length { get { return Values.Length; } }

    public static Vector operator +(Vector v1,Vector v2)
    {
        if (v1.Length != v2.Length)
        {
            throw new VectorTypeException("Vector Dimensions Must Be Equal");
        }
        else
        {
            //perform generic matrix addition/operation
            double[] newValues = new double[v1.Length];
            for (int i = 0; i < v1.Length; i++)
            {
                newValues[i] = v1.Values[i] + v2.Values[i];
            }

            //or use some factory/service to give you a Vector2D,Vector3D,or VectorND
            return new Vector() { Values = newValues };
        }
    }
}

public class Vector2D : Vector
{
    public double X
    {
        get { return Values[0]; }
        set { Values[0] = value; }
    }
    public double Y
    {
        get { return Values[1]; }
        set { Values[1] = value; }
    }
}


public class Vector3D : Vector
{
    public double X
    {
        get { return Values[0]; }
        set { Values[0] = value; }
    }
    public double Y
    {
        get { return Values[1]; }
        set { Values[1] = value; }
    }
    public double Z
    {
        get { return Values[2]; }
        set { Values[2] = value; }
    }
}

EDITx3：基于你的最新评论,我想你可以在每个子类上实现运算符重载,在静态方法中执行共享逻辑(比如在基类Vector类中),并在某处进行切换/大小写检查以提供特定的子类：

private static Vector Add(Vector v1,or VectorND
            switch (newValues.Length)
            {
                case 1 :
                    return new Vector1D() { Values = newValues };
                case 2 :
                    return new Vector2D() { Values = newValues };
                case 3 :
                    return new Vector3D() { Values = newValues };
                case 4 :
                    return new Vector4D() { Values = newValues };
                //... and so on
                default :
                    throw new DimensionOutOfRangeException("Do not support vectors greater than 10 dimensions");
                    //or you could just return the generic Vector which doesn't expose X,Y,Z values?
            }
        }
    }

然后您的子类将具有：

public class Vector2D
    {
        public static Vector2D operator +(Vector2D v1,Vector2D v2)
        {
            return (Vector2D)Add(v1,v2);
        }
    }

    public class Vector3D
    {
        public static Vector3D operator +(Vector3D v1,Vector3D v2)
        {
            return (Vector3D)Add(v1,v2);
        }
    }

一些重复,但我没有看到一个方法绕过它顶部允许编译器执行此操作：

Vector3 v1 = new Vector3(2,2,2);
    Vector3 v2 = new Vector3(1,1,1);
    var v3 = v1 + v2; //Vector3(3,3,3);
    Console.WriteLine(v3.X + "," + v3.Y + "," + v3.Z);

或其他方面：

Vector2 v1 = new Vector2(2,2);
    Vector2 v2 = new Vector2(1,1);
    var v3 = v1 + v2; //Vector2(3," + v3.Y); // no "Z" property to output!