C#中运算符重载

运算符重载：在类或结构体上定义，可以让对象进行加减乘除和比较等操作，而不仅仅是调用方法和属性。

声明：运算符重载的声明与静态方法基本相同，使用 public 和 static ，区别是有operator 关键字（放在返回类型之后，方法名之前），表示是自定义的运算符重载，方法名是相应的运算符。

注意：使用 public 和 static 表明 运算符重载是与类或结构相关联的，而不是与他们的实例关联。

1、下面给出重载加减乘除运算符示例：

// 自定义的向量类
public class MyVector
{
	// 向量的三个坐标轴：x,y,z,这里用只读属性表示
	public int X{get;}
	public int Y{get;}
	public int Z{get;}
	// 初始化向量的值
	public MyVector(int x,int y,int z)
	{
		X = x;
		Y = y;
		Z = z;
	}
	// 自定义的 + 运算重载，两个向量相加结果为相应坐标之和
	public static  MyVector operator +(MyVector left,MyVector right)
	{
		return new MyVector(left.X+right.X,left.Y+right.Y,left.Z+right.Z);
	} 
	// 自定义的 * 运算重载，两个向量相加结果为相应坐标之积
	public static  MyVector operator *(MyVector left,MyVector right)
	{
		return new MyVector(left.X*right.X,left.Y*right.Y,left.Z*right.Z);
	} 
	// 自定义的 * 运算重载1，计算一个常数乘以向量
	public static  MyVector operator *(int value,MyVector right)
	{
		return new MyVector(value*right.X,value*right.Y,value*right.Z);
	} 
	// 自定义的 * 运算重载2，计算一个向量乘以常数
	public static  MyVector operator *(MyVector right,int value)
	{
		return value*right;
	} 
}

注意：在调用运算符重载的时候，编译器会查看所有可用的重载，如果没有会报错。

下面是调用示例：

MyVector left = new MyVector(2,3,4);
MyVector right = new MyVector(4,5,6);
// 重载了 + 之后，直接调用两个向量 left 和 right 相加
MyVector result = left + right; // result = (6,8,10);
// 重载了 * 之后，直接调用两个向量 left 和 right 相乘
MyVector result1 = left * right; // result1 = (8,15,24);
// 调用一个常数 value 和 right 相乘
MyVector result2 = 2 * right; // result1 = (8,10,12);
// 调用一个向量 right 和 value 相乘
MyVector result3 = right * 3; // result1 = (12,15,18);

注意：因为 C# 中 x + = y 等价于 x = x + y，所以重载了加减乘除运算符后，相当于对应的 +=，-=，*=，/= 都重载了。

2、下面给出重载类中比较运算符的示例：

注意：基本上所有的引用类型的比较相等的方式（如 ReferenceEquals，Equals，== ）都是比较的引用，除了 一些比较明显的，如 string 类型重载了比较运算符，是比较值而不是引用。

C#中比较对象的相等性：点击打开链接

// 表示向量的类
public class OtherVector
{
	// 向量的三个坐标轴：x,y,z,这里用只读属性表示
	public int X{get;}
	public int Y{get;}
	public int Z{get;}
	// 初始化向量的值
	public OtherVector(int x,int y,int z)
	{
		X = x;
		Y = y;
		Z = z;
	}
	// 自定义的 == 重载，比较两个向量的对应坐标是否相等,若相等，返回 true，否则返回 false
	public static bool operator ==(OtherVector left,OtherVector right)
	{
		return (left.X == right.X && left.Y == right.Y && left.Z == right.Z);
	} 
	// 自定义的 != 运算重载，与 == 结果相反
	public static  bool operator !=(OtherVector left,OtherVector right)
	{
		return !(left == right);
	} 
	// 重写 Equals() 方法
	public override bool Equals(object obj)
	{
		// 空引用过滤
		if(obj == null) return false;
		// 不为空则调用重写之后的 == 进行比较
		return this == (OtherVector)obj;
	}
	// 重写 GetHashCode 方法，这里使用了父类的方法
	public override int GetHashCode()
	{
		return base.GetHashCode();
	}
}

注意：

1、比较运算符的返回值是布尔值（true 或false）；

2、比较运算符是成对出现的，所以重写时要成对的重写（如 == 和 !=， < 和 >）；

3、在重写了 == 和 != 运算符后，还应该要重写 Equals（）和 GetHashCode（）方法，否则编译会报错；

4、Equals（）方法有静态和实例两种，静态的可以比较空引用，实例的不行。静态方法在比较非空的对象时是调用的实例Equals，所以重写了实例 Equals（）方法后，相当于也重写了静态的方法。

下面给出调用示例：

OtherVector otherLeft = new OtherVector(1,2,3);
OtherVector otherRight = new OtherVector(1,2,3);
// 比较两个向量是否相等
bool isEqual = otherLeft == otherRight; // true
// 调用重写后的 实例Equals() 方法
bool isEqual1 = otherLeft.Equals(otherRight); // true
// 重写了 实例的Equals() 相当于重写了 静态的Equals() 方法 
bool isEqual2 = Equals(otherLeft,otherRight); // true

运算符重载的适用情况：

1、在数学领域中有相应的建模，有运算公式，比如向量，矩阵等。

2、在财务方面，关于金钱的处理，做一些复杂的计算。