运算符重载就是指重写 1+1 = ?中的加号“+”,那样我们可以实现1 + 1 = 1。类似的,其他运算符重载也是这样的道理,然运算符的重载用来干这些事显得鸡肋了些,更多的是,通过运算符重载去实现一般的加减乘除不能实现的运算,例如:
——> 矢量的加减乘除?
class Program
{
static void Main(string[] args)
{
Vector vect1, vect2, vect3, vect4;
vect1 = new Vector(3.0, 2.0, 1.0);
vect2 = new Vector(2.0, -4.0, -4.0);
vect3 = vect1 + vect2;
vect4 = new Vector(3.0, 2.0, 1.0);
Console.WriteLine("Vect1 = {0}", vect1.ToString());
Console.WriteLine("Vect2 = {0}", vect2.ToString());
Console.WriteLine("Vect3 = {0}", vect3.ToString());
Console.WriteLine("Vect1 == Vect4 {0}", vect1 == vect4);
Console.ReadKey();
}
}
/// <summary>
/// 向量结构
/// </summary>
struct Vector
{
public double x, y, z;
public Vector(double x, double y, double z)
{
this.x = x;
this.y = y;
this.z = z;
}
public Vector(Vector rhs)
{
this.x = rhs.x;
this.y = rhs.y;
this.z = rhs.z;
}
public override string ToString()
{
return "(" + x + ", " + y + ", " + z + ")";
}
/// <summary>
/// 向量加法
/// </summary>
/// <param name="lhs"></param>
/// <param name="rhs"></param>
/// <returns></returns>
public static Vector operator +(Vector lhs, Vector rhs)
{
Vector result = new Vector(lhs);
result.x += rhs.x;
result.y += rhs.y;
result.z += rhs.z;
return result;
}
/// <summary>
/// 向量点积
/// </summary>
/// <param name="lhs"></param>
/// <param name="rhs"></param>
/// <returns></returns>
public static Vector operator *(double lhs, Vector rhs)
{
return new Vector(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z);
}
/// <summary>
/// 向量点积
/// </summary>
/// <param name="lhs"></param>
/// <param name="rhs"></param>
/// <returns></returns>
public static Vector operator *(Vector rhs, double lhs)
{
return lhs * rhs;
}
public static bool operator ==(Vector lhs, Vector rhs)
{
if (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z)
return true;
else
return false;
}
public static bool operator !=(Vector lhs, Vector rhs)
{
if (lhs.x != rhs.x && lhs.x != rhs.y && lhs.z != rhs.z)
return true;
else
return false;
}
}
以上两种比较方式存在问题:
1、如果某参数为null,则出现 null.Equals(obj) 的情况,会触发空引用异常
2、这样的比较无法确认只是值相等,不是指向同一个东西(值相等,地址不同),还是指向同一个(即值与地址都相等)
3、重载了“==”、“!=”运算符却没有没有实现Object.Equals(obj)方法(这里对本例来说,不是很重要,但应当知道程序的缺点在哪)
上述的“!=”、“==”比较方式仅根据矢量元素的值,来对它们进行相等性比较。对于大多数结构,这就是我们希望的,但在某些情况下,可能需要仔细考虑相等的含义。例如,如果有嵌入的类,那么是应比较引用 是否指向同一个对象(浅度比较),还是应比较对象的值是否相等(深度比较)? 浅度比较是比较对象是否指向内存中的同一个位置,而深度比较是比较对象的值和属性是否相等.