C#的运算符重载

运算符重载看起来与标准静态方法声明类似，但它们使用关键字operator和运算符本身，而不是一个方法名：

public static 返回类型 operator +(类型1 变量1,类型2 变量2)

{

//返回类型，类型1，类型2 ，可以相同，也可以全部不同

}

如果使用混合类型的话，需要注意的是，不可以将相同的运算符添加到不同的类进行重载。

还需要注意，操作数的顺序也必须与运算符重载的参数顺序保持一致。

 class AddClass1
    {
        public int val;
        public static AddClass1 operator +(AddClass1 op1,AddClass1 op2)
        {
            AddClass1 returnVal = new AddClass1();
            returnVal.val = op1.val + op2.val;
            return returnVal;
        }

        public static AddClass1 operator ~(AddClass1 op1)
        {
            AddClass1 returnVal = new AddClass1();
            returnVal.val = ~op1.val;//按位取反
            return returnVal;
        }

        public static AddClass3 operator +(AddClass1 op1, AddClass2 op2)
        {
            AddClass3 returnVal = new AddClass3();
            returnVal.val = op1.val + op2.val;
            return returnVal;
        }
    }

    class AddClass2
    {
        public int val;
    }

    class AddClass3
    {
        public int val;
    }

    class Program
    {
        static void Main(string[] args)
        {
            AddClass1 op1 = new AddClass1();
            op1.val = 5;
            AddClass2 op2 = new AddClass2();
            op2.val = 5;
            AddClass3 op3 = op1 + op2;
            Console.WriteLine("op1+op2 = {0}", op3.val);
            Console.ReadKey();
        }
    }

如果重载了true和false运算符，就可以在布尔表达式中直接使用类。例如

ClassA a; if(a){}

以下运算符不能重载，例如+=，=，&&，||

此外>,<必须成对重载 [>=,<=]

此规则也==,!=,但是对于这些==,!=运算符，常常需要重写Object.Equals()和Object.GetHashCode()，因为这两个函数也可以用于比较对象。

重写这些方法。可以确保无论类的用户使用什么技术，都能得到相同的结果。这不太重要，但应增加进来，以保证其完整性。

它需要下述非静态重写方法

class AddClass1
    {
        public int val;

        /// <summary>
        /// ==和!=的重载必须成对出现
        /// </summary>
        /// <param name="op1"></param>
        /// <param name="op2"></param>
        /// <returns></returns>
        public static bool operator ==(AddClass1 op1, AddClass1 op2)
        {
            return (op1.val == op2.val);
        }

        /// <summary>
        /// ==和!=的重载必须成对出现
        /// </summary>
        /// <param name="op1"></param>
        /// <param name="op2"></param>
        /// <returns></returns>
        public static bool operator !=(AddClass1 op1, AddClass1 op2)
        {
            return !(op1 == op2);
        }

        public override bool Equals(object obj)
        {
            if (obj is AddClass1)
            {
                return val == ((AddClass1)obj).val;
            }
            else
            {
                throw new ArgumentException(string.Format("Can not compare AddClass1 objects with objects of type {0}", obj.GetType().ToString()));
            }
        }

        public override int GetHashCode()
        {
            return val;
        }
    }

GetHashCode()可根据其状态，获取对象实例的一个唯一的int值[类似于主键，唯一标示符]

需要注意的是Equals必须使用object参数，否则就变成重载函数而不是重写了。