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. }