C#操作符重载是什么？
是指允许用户使用用户定义的类型编写表达式的能力。
例如，通常需要编写类似于以下内容的代码，以将两个数字相加。很明显，sum 是两个数字之和。
int i = 5; int sum = i + j;
如果可以使用代表复数的用户定义的类型来编写相同类型的表达式，那当然是最好不过了：
Complex i = 5;Complex sum = i + j;
运算符重载允许为用户定义的类型重载（即指定明确的含义）诸如“+”这样的运算符。如果不进行重载，则用户需要编写以下代码：
Complex i = new Complex(5);Complex sum = Complex.Add(i, j);
此代码可以很好地运行，但 Complex 类型并不能象语言中的预定义类型那样发挥作用。
在我看来是操作符重载是让struct、class、Interface等能够进行运算。
如时实现C#操作符重载。
先写关键词public和static，后跟返回类型，后跟operator关键词，后跟要声明的操作符符号，最后在对一对圆括号中添加恰当的参数。
如下例中的struct Hour中的public static Hour operator+ (Hour lhs,Hour rhs){...}
C#操作符重载方法：
1、编写操作符重载方法。
2、实例化后，进行操作符运算
下边用C#操作符重载代码进行说明：
1. class Program
2. {
3. static void Main(string[] args)
4. {
5. Hour hrValue1 = new Hour(10);
6. Hour hrValue2 = new Hour(20);
7.
8. //2、得到两个Hour相加结果
9. Hour hrSum = hrValue1 + hrValue2;
10.
11. //得到Hour+Int的结果
12. Hour hrSumInt = hrValue1 + 10;
13.
14. //得到Int+Hour的结果
15. Hour hrIntSum = 11 + hrValue2;
16. Console.WriteLine("hrValue1 + hrValue2 = {0}", hrSum.iValue);
17. Console.WriteLine("hrValue1 + 10 = {0}", hrSumInt.iValue);
18. Console.WriteLine("11 + hrValue2 = {0}", hrIntSum.iValue);
19. Console.ReadKey();
20. }
21. struct Hour
22. {
23. private int value;
24. //此构造函数根据int值创建Hour类 ，C#操作符重载
25. public Hour(int iValue)
26. {
27. this.value = iValue;
28. }
29. //定义一个属性，便于取用value值
30. public int iValue
31. {
32. get
33. {
34. return value;
35. }
36. } //C#操作符重载
37. //1、声明一个二元操作符，将两个Hour类加到一起
38. public static Hour operator+ (Hour lhs,Hour rhs)
39. {
40. return new Hour(lhs.value + rhs.value);
41. }
42.
43. /*
44. 操作符是public的。所有操作符都必须是public的
45.
46. 操作符是static的。所有操作符都必须是static的，操作永远不具有多态性，
47.
48. 面且不能使用virtual、abstract、override或者sealed修饰符。
49.
50. 二元操作符(比如+)有两个显式参数；一元操作符有一个显式的参数
51.
52. 我们有了public Hour(int iValue)构造函数，就可以将一个int与Hour相加，只是首先要将int转换成为Hour
53.
54. hour a= ;
55.
56. int b= ;
57.
58. Hour sum=a+new Hour(b);
59.
60. 虽然上述代码完全有效，但相较于让一个Hour和一个int直接相加它即不清晰也不准确。
61.
62. 为了使Hour可以+ int，必须声明一个二元操作符＋，它的第一个参数是Hour，第二个参数是一个int。
63. C#操作符重载
64. */
65. public static Hour operator+ (Hour lhs,int rhs)
66. {
67. return lhs + new Hour(rhs);
68. }
69. //使一个int 可以＋hour。
70. public static Hour operator +(int lhs, Hour rhs)
71. {
72. return new Hour(lhs)+rhs;
73. }
74. }
75. }
C#操作符重载示例2：
1. struct Hour
2. {
3. public int iValue;
4. //构造函数
5. public Hour(int initialValue)
6. {
7. this.iValue = initialValue;
8. }
9. //1、定义操作符重载（一元操作符）
10. public static Hour operator ++ (Hour huValue)
11. {
12. huValue.iValue++;
13. return huValue;
14. } //C#操作符重载
15.
16. //==操作符是二元操作符，必须带有两个参数
17. public static bool operator==(Hour lhs,Hour rhs)
18. {
19. return lhs.iValue == rhs.iValue;
20. }
21. public static bool operator!=(Hour lhs,Hour rhs)
22. {
23. return lhs.iValue != rhs.iValue;
24. }
25. }
26.
27. //++操作符有前缀和后缀的形式，C#能智能地为前缀后后缀使用同一个操作符。
28.
29. static void Main(string[] args)
30. {
31. //2、实例化类 ,C#操作符重载
32.
33. Hour hu = new Hour(10);
34. //3、
35. //操作符重载
36.
37. hu++;
38. //输出重载后的结果
39.
40. Console.WriteLine("Hu++ = {0}", hu.iValue);
41. //C#操作符重载
42.
43. ++hu;
44. //输出重载后的结果
45.
46. Console.WriteLine("Hu++ = {0}", hu.iValue);
47.
48. Console.ReadKey();
49. }
C#操作符重载问题的提出
在面向对象的程序设计中，自己定义一个类，就等于创建了一个新类型。类的实例和变量一样，可以作为参数传递，也可以作为返回类型。
C#操作符重载问题比如对于两个整型变量，使用算术操作符可以简便地进行算术运算：
1. class A
2. {
3. public int x;
4. public int y;
5. public int Plus{
6. return x+y;
7. }
8. }
C#操作符重载问题再比如，我们希望将属于不同类的两个实例的数据内容相加：
9. class B
10. {
11. public int x;
12. }
13. class Test
14. {
15. public int z;
16. public static void Main{
17. A a=new A();
18. B b=new B();
19. z=a.x+b.x;
20. }
21. }
使用a.x+b.x这种写法不够简洁，也不够直观。更为严重的问题是，如果类的成员中声明时使用的不是publixc修饰符的话，这种访问就是非法的。
我们知道，在C#中，所有数据要么属于某个类，要么属于某个类的实例，充分体现了面向对象的思想。因此，为了表达上的方便，人们希望可以重新给已定义的操作符赋予新的含义，在特定的类的实例上进行新的解释。这就需要通过操作符重载来解决。
使用成员方法重载操作符
C#操作符重载总是在类中进行声明，并且通过调用类的成员方法来实现。
操作符重载声明的格式为：
22. type operator operator-name(formal-param-list)
C#操作符重载可以实现的有：
23. + - ! ~ ++ -- true false
24.
25. * / % & | ^ << >> == != > < >= <=
但也有一些操作符是不允许进行重载的，如：
26. =,&&,||,?:,new,typeof,sizeof,is
C#操作符重载之一元操作符重载
顾名思义，一元操作符重载时操作符只作用于一个对象，此时参数表为空，当前对象作为操作符的单操作数。
下面我们举一个角色游戏中经常遇到的例子。扮演的角色具有内力、体力、经验值、剩余体力、剩余内力五个属性，每当经验值达到一定程序时，角色便会升级，体力、内力上升，剩余体力和内力补满。“升级”我们使用重载操作符“++”来实现。
C#操作符重载程序:
27. using System;
28. class Player
29. {
30. public int neili;
31. public int tili;
32. public int jingyan;
33. public int neili_r;
34. public int tili_r;
35. public Player()
36. {
37. neili=10;
38. tili=50;
39. jingyan=0;
40. neli_r=50;
41. tili_r=50;
42. }
43. public static Player operator ++(Player p){
44. p.neili=p.neili+50;
45. p.tili=p.tili+100;
46. p.neili_r=p.neili;
47. p.tili_r=p.tili;
48. return p;
49. }
50. public void Show()
51. {
52. Console.WriteLine("Tili:{0}",tili);
53. Console.WriteLine("Neili:{0}",neili);
54. Console.WriteLine("Tili_full:{0}",tili_r);
55. Console.WriteLine("Neili_full:{0}",neili_r);
56. }
57. }
58. class Test
59. {
60. public static void Main(){
61. Player man=new Player();
62. man.Show();
63. man++;
64. Console.WriteLine("Now upgrading...:");
65. man.Show();
66. }
67. }
C#操作符重载之二元操作符重载
大多数情况下我们使用二元操作符重载。这时参数表中有一个参数，当前对象作为该操作符的左操作数，参数作为操作符的右操作数。
下面我们给出二元操作符重载的一个简单例子，即笛卡儿坐标相加。
C#操作符重载程序:
68. using System;
69. class DKR
70. {
71. public int x,y,z;
72. public DKR(int vx,int vy,int vz){
73. x=vx;
74. y=vy;
75. z=vz;
76. }
77. public static DKR operator +(DKR d1,DKR d2)
78. {
79. DKR dkr=new DKR(0,0,0);
80. dkr.x=d1.x+d2.x;
81. dkr.y=d1.y+d2.y;
82. dkr.z=d1.z+d2.z;
83. return dkr;
84. }
85. } //C#操作符重载
86. class Test
87. {
88. publixc statixc void Main(){
89. DKR d1=new DKR(3,2,1);
90. DKR d2=new DKR(0,6,5);
91. DKR d3=d1+d2;
92. Console.WriteLine("The 3d
93. location of d3 is:{0},{1},{2}",d3.x,d3.y,d3,z);
94. }
95.
96. }