C#中的运算符重载

C# 允许用户自定义类型通过使用 operator 关键字定义静态成员函数来重载运算符。

注意：

• 必须用public修饰，必须是类的静态的方法。
• 重载相等运算符（==）时，还必须重载不相等运算（!=）。
• < 和 > 运算符以及 <= 和 >= 运算符也必须成对重载。

可以重载的运算符：

• 可以重载的一元运算符：+、-、!、~、++、--、true 和 false
• 可以重载的二进制运算符：+, -, *, /, %, &, |, ^, <<, >>
• 可以重载的比较运算符：==, !=, <, >, <=, >=

不能重载的运算符：

• &&, || 条件逻辑运算符不能重载，但可使用能够重载的 & 和 | 进行计算。
• []不能重载数组索引运算符，但可定义索引器。
• ()不能重载转换运算符，但可定义新的转换运算符（请参见 explicit 和 implicit）。
• +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=赋值运算符不能重载，但 += 可使用 + 计算
• =、.、?:、->、new、is、sizeof 和 typeof 不能重载这些运算符。

注意：

• 若要在自定义类中重载运算符，您需要在该类中创建具正确签名的方法。该方法必须命名为“operator X”，其中 X 是正在重载的运算符的名称或符号。
• 一元运算符具有一个参数，二元运算符具有两个参数。
• 在每种情况下，参数的类型必须与声明运算符的类或结构的类型相同。

 下面是个人写的一小段练习代码：

/* 设计一个复数类（Complex），
 * 包含两个字段（实部x和虚部y），
 * 对运算符进行重载，实现两个
 * 复数的加法和减法运算、
 * 以及判断两个复数是否一致
 */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace homeWork4
{
    class Program
    {
        static void Main(string[] args)
        {
            Complex com1, com2, com3;
            com1 = new Complex(1, 4);
            com2 = new Complex(2, 6);
            com3 = new Complex();
            com3 = com1 + com2;
            Console.WriteLine(com1 + " + " + com2 + " = " + com3);
            com3 = com1 - com2;
            Console.WriteLine(com1 + " - " + com2 + " = " + com3);
            if (com1 == com2)
                Console.WriteLine("com1和com2一致");
            else
                Console.WriteLine("com1和com2不一致");
            Console.ReadKey();
        }
    }

    class Complex
    {
        public double x, y;
        public Complex()
        { x = y = 0; }
        public Complex(double x, double y)
        {
            this.x = x;
            this.y = y;
        }
        public static Complex operator +(Complex comp1, Complex comp2)
        {
            Complex comp = new Complex();
            comp.x = comp1.x + comp2.x;
            comp.y = comp1.y + comp2.y;
            return comp;
        }
        public static Complex operator -(Complex comp1, Complex comp2)
        {
            Complex comp = new Complex();
            comp.x = comp1.x - comp2.x;
            comp.y = comp1.y - comp2.y;
            return comp;
        }
        public override string ToString()
        {
            return "(" + x + "," + y + ")";
        }
        public static bool operator ==(Complex c1, Complex c2)
        {
            //将c1对象转为object再进行判断  
            //这里的object.Equals(c1, null)也可以写成  
            //c1 as object == null  
            if (object.Equals(c1, null) || object.Equals(c2, null))
            {
                return object.Equals(c1, c2);
            }
            return c1.x == c2.x && c1.y == c2.y;
        }

        public static bool operator !=(Complex c1, Complex c2)
        {
            if (object.Equals(c1, null) || object.Equals(c2, null))
            {
                return !object.Equals(c1, c2);
            }
            return c1.x != c2.x || c1.y != c2.y;
        }
    };
}

作者：耑新新，发布于  博客园

转载请注明出处，欢迎邮件交流：zhuanxinxin@aliyun.com