重载运算符c#向量_C#_Vector_Operator Keyword

重载运算符c#向量

c# vector

重载运算符c#向量,c#,vector,operator-keyword,C#,Vector,Operator Keyword,所以，我试图重写c#中的“-”运算符，以便能够减去2个向量，但我的类无法实现向量 namespace Vectors { class VectorUtilv { private Point _p; private Point _p2; private Vector _v; public Vector V { get { return _v; } s

所以，我试图重写c#中的“-”运算符，以便能够减去2个向量，但我的类无法实现向量

namespace Vectors
{
    class VectorUtilv
    {
        private Point _p;
        private Point _p2;
        private Vector _v;


         public Vector V
        {
            get { return _v; }
            set { _v = value; }
        }

        public Point AddVector(Vector v)
        {
            _p.X = (_p.X + v.X);
            _p2.Y = (_p.Y + v.Y);

            return _p2;
        }

        // This is where I am trying to override but I cant add the v.X or 
        // the v.Y because it is not a vector. If i cast it as a vector the 
        // override doesn't work.
        //////////////////////////////////////////////////////////////////
        public static VectorUtilv operator -(Vector a, Vector b)
        {
            Vector v = new Vector();
            v.X = a.X - b.X;
            v.Y = a.Y - b.Y;
            return v;
        }
    }    
}

您知道如何解决这个问题吗？

您只能重写自己类中的运算符

将所有代码移动到

向量

类。

您只能覆盖其自身类中的运算符

将所有代码移动到

向量

类。

您只能覆盖其自身类中的运算符

将所有代码移动到

向量

类。

您只能覆盖其自身类中的运算符

将所有代码移动到向量类。

在向量类中，重写其中的“-”运算符

public class Vector
{
    public int X { get; set; }
    public int Y { get; set; }

    public static Vector operator -(Vector a, Vector b)
    {
        Vector v = new Vector();
        v.X = a.X - b.X;
        v.Y = a.Y - b.Y;
        return v;
    }
}

然后，你可以这样使用它

Vector v1 = new Vector { X = 5, Y = 9};
Vector v2 = new Vector { X = 3, Y = 4 };
Vector vr = v1 - v2;
Console.WriteLine("Resultant Vector X: {0} & Y:{1}", vr.X, vr.Y);

我希望它能对您有所帮助。

在vector类中，重写其中的“-”运算符

public class Vector
{
    public int X { get; set; }
    public int Y { get; set; }

    public static Vector operator -(Vector a, Vector b)
    {
        Vector v = new Vector();
        v.X = a.X - b.X;
        v.Y = a.Y - b.Y;
        return v;
    }
}

然后，你可以这样使用它

Vector v1 = new Vector { X = 5, Y = 9};
Vector v2 = new Vector { X = 3, Y = 4 };
Vector vr = v1 - v2;
Console.WriteLine("Resultant Vector X: {0} & Y:{1}", vr.X, vr.Y);

我希望它能对您有所帮助。

在vector类中，重写其中的“-”运算符

public class Vector
{
    public int X { get; set; }
    public int Y { get; set; }

    public static Vector operator -(Vector a, Vector b)
    {
        Vector v = new Vector();
        v.X = a.X - b.X;
        v.Y = a.Y - b.Y;
        return v;
    }
}

然后，你可以这样使用它

Vector v1 = new Vector { X = 5, Y = 9};
Vector v2 = new Vector { X = 3, Y = 4 };
Vector vr = v1 - v2;
Console.WriteLine("Resultant Vector X: {0} & Y:{1}", vr.X, vr.Y);

我希望它能对您有所帮助。

在vector类中，重写其中的“-”运算符

public class Vector
{
    public int X { get; set; }
    public int Y { get; set; }

    public static Vector operator -(Vector a, Vector b)
    {
        Vector v = new Vector();
        v.X = a.X - b.X;
        v.Y = a.Y - b.Y;
        return v;
    }
}

然后，你可以这样使用它

Vector v1 = new Vector { X = 5, Y = 9};
Vector v2 = new Vector { X = 3, Y = 4 };
Vector vr = v1 - v2;
Console.WriteLine("Resultant Vector X: {0} & Y:{1}", vr.X, vr.Y);

我希望它能对您有所帮助。

因为您正在尝试为类定义运算符。在类的类型为的运算符中应至少使用它的一个参数。例如，您不能使用class

Car

和define Operator witch只获取

int

不能重写现有类的运算符。只能重写您自己的类

若你们不能修改Vector类，那个么你们应该声明你们自己的名为Vector的类。或者将类的类型用作运算符

所以你可以

    class VectorUtilv
    {
        private Point _p;
        private Point _p2;
        private Vector _v;
        public static VectorUtilv operator -(VectorUtilv a, VectorUtilv b)
        {
            //...
        }
    }

或

但是如果你使用解决方案2。然后在使用Vector时需要使用限定符

System.Windows.Vector // is in Windows assembly
Vector // is your class

因为您正在尝试为类定义运算符。在类的类型为的运算符中应至少使用它的一个参数。例如，您不能使用class

Car

和define Operator witch只获取

int

不能重写现有类的运算符。只能重写您自己的类

若你们不能修改Vector类，那个么你们应该声明你们自己的名为Vector的类。或者将类的类型用作运算符

所以你可以

    class VectorUtilv
    {
        private Point _p;
        private Point _p2;
        private Vector _v;
        public static VectorUtilv operator -(VectorUtilv a, VectorUtilv b)
        {
            //...
        }
    }

或

但是如果你使用解决方案2。然后在使用Vector时需要使用限定符

System.Windows.Vector // is in Windows assembly
Vector // is your class

因为您正在尝试为类定义运算符。在类的类型为的运算符中应至少使用它的一个参数。例如，您不能使用class

Car

和define Operator witch只获取

int

不能重写现有类的运算符。只能重写您自己的类

若你们不能修改Vector类，那个么你们应该声明你们自己的名为Vector的类。或者将类的类型用作运算符

所以你可以

    class VectorUtilv
    {
        private Point _p;
        private Point _p2;
        private Vector _v;
        public static VectorUtilv operator -(VectorUtilv a, VectorUtilv b)
        {
            //...
        }
    }

或

但是如果你使用解决方案2。然后在使用Vector时需要使用限定符

System.Windows.Vector // is in Windows assembly
Vector // is your class

因为您正在尝试为类定义运算符。在类的类型为的运算符中应至少使用它的一个参数。例如，您不能使用class

Car

和define Operator witch只获取

int

不能重写现有类的运算符。只能重写您自己的类

若你们不能修改Vector类，那个么你们应该声明你们自己的名为Vector的类。或者将类的类型用作运算符

所以你可以

    class VectorUtilv
    {
        private Point _p;
        private Point _p2;
        private Vector _v;
        public static VectorUtilv operator -(VectorUtilv a, VectorUtilv b)
        {
            //...
        }
    }

或

但是如果你使用解决方案2。然后在使用Vector时需要使用限定符

System.Windows.Vector // is in Windows assembly
Vector // is your class

谢谢你的回复。我希望在我弄明白之前我已经检查过了。会节省我很多时间。我最终几乎完全按照你们说的做了。这是我的

公共静态VectorUtil运算符-（VectorUtil aHeroPoint，VectorUtil bEnemyPoint）{ VectorUtil v=新的VectorUtil（）； v、 Vec=新向量（（aHeroPoint.\p.X-bEnemyPoint.\u p.X），（aHeroPoint.\p.Y-bEnemyPoint.\u p.Y））；返回v；

}感谢您的热烈响应。我希望在我弄明白之前我已经检查过了。会节省我很多时间。我最终几乎完全按照你们说的做了。这是我的

}

但我认为他不能这样做，因为Vector在

系统中。Windows

汇编中，不能被删除modified@M.kazemAkhgary：那么他就不走运了。此外，我们还有内置的

Vector.Subtract（v1，v2）

方法来执行减法。但我认为他不能这样做，因为Vector在

系统中。Windows

程序集中，不能使用modified@M.kazemAkhgary：那么他就不走运了。此外，我们还有内置的

Vector.Subtract（v1，v2）

方法来执行减法。但我认为他做不到，因为Vector在

系统中。Windows