C#中的运算符重载

Posted 2020-08-20

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

注意：

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

可以重载的运算符：

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

不能重载的运算符：

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

注意：

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

 

 1 /* 设计一个复数类（Complex），
 2  * 包含两个字段（实部x和虚部y），
 3  * 对运算符进行重载，实现两个
 4  * 复数的加法和减法运算、
 5  * 以及判断两个复数是否一致
 6  */
 7 
 8 using System;
 9 using System.Collections.Generic;
10 using System.Linq;
11 using System.Text;
12 
13 namespace homeWork4
14 {
15     class Program
16     {
17         static void Main(string[] args)
18         {
19             Complex com1, com2, com3;
20             com1 = new Complex(1, 4);
21             com2 = new Complex(2, 6);
22             com3 = new Complex();
23             com3 = com1 + com2;
24             Console.WriteLine(com1 + " + " + com2 + " = " + com3);
25             com3 = com1 - com2;
26             Console.WriteLine(com1 + " - " + com2 + " = " + com3);
27             if (com1 == com2)
28                 Console.WriteLine("com1和com2一致");
29             else
30                 Console.WriteLine("com1和com2不一致");
31 
32             Console.ReadKey();
33         }
34     }
35 
36     class Complex
37     {
38         public double x, y;
39         public Complex()
40         { x = y = 0; }
41         public Complex(double x, double y)
42         {
43             this.x = x;
44             this.y = y;
45         }
46         public static Complex operator +(Complex comp1, Complex comp2)
47         {
48             Complex comp = new Complex();
49             comp.x = comp1.x + comp2.x;
50             comp.y = comp1.y + comp2.y;
51             return comp;
52         }
53         public static Complex operator -(Complex comp1, Complex comp2)
54         {
55             Complex comp = new Complex();
56             comp.x = comp1.x - comp2.x;
57             comp.y = comp1.y - comp2.y;
58             return comp;
59         }
60         public override string ToString() 
61         {
62             return "(" + x + "," + y + ")";
63         }
64         public static bool operator ==(Complex c1, Complex c2)
65         {
66             //将c1对象转为object再进行判断  
67             //这里的object.Equals(c1, null)也可以写成  
68             //c1 as object == null  
69             if (object.Equals(c1, null) || object.Equals(c2, null))
70             {
71                 return object.Equals(c1, c2);
72             }
73 
74 
75             return c1.x == c2.x && c1.y == c2.y;
76         }
77 
78 
79         public static bool operator !=(Complex c1, Complex c2)
80         {
81             if (object.Equals(c1, null) || object.Equals(c2, null))
82             {
83                 return !object.Equals(c1, c2);
84             }
85 
86 
87             return c1.x != c2.x || c1.y != c2.y;
88         }  
89     };
90 }