?C++重載運算符和重載函數

C++的運算符重載在維基百科中的定義如下：

在計算機程序設計中，運算符重載（英語：operator overloading）是多態的一種。這里，運算符（比如+，=或==）被當作多態函數，它們的行為隨著其參數類型的不同而不同。運算符并不一定總是符號。

運算符重載通常只是一種語法糖。它可以簡單地通過函數調用來模擬：

a + b * c

在一個支持運算符重載的語言里，上面的寫法要比下面的寫法有效而簡練：

add(a, multiply(b, c))

（假設運算符* 的優先級高于運算符 +）

當一種語言允許運算符在某種情況下被隱式調用的時候，運算符重載將不只提供寫法上的方便。例如，Ruby中的to_s運算符就是如此，它返回一個對象的字符串表示。

C++中的函數重載在維基百科中的定義如下：

函數重載（英語：function overloading），是Ada、C++、C#、D和Java等編程語言中具有的一項特性，這項特性允許創建數項名稱相同但輸入輸出類型或個數不同的子程序，它可以簡單地稱為一個單獨功能可以執行多項任務的能力。

C++允許在同一個作用域中的某個函數或者運算符指定多個定義，這樣的方式分別被稱為函數重載和運算符重載。

重載聲明是指的一個與之前已經在這個作用域內聲明過的函數或者方法具有相同的名稱的聲明，但是他們的參數和定義并不完全相同。

當調用一個重載函數和重載運算發的時候，編譯器會通過把使用的參數類型的定義中的參數類型進行比較，最終選定最合適的定義，選擇最合適的重載函數或者重載運算符的過程，這樣的過程成員為重載決策。

C++中的函數重載

在同一個作用域內，可以聲明幾個功能類似的同名函數，但是這些同名函數的參數（參數個數，參數類型，參數順序）必須不同，同時不能僅僅通過返回類型的不同來重載函數。

接下來我們看一段函數重載的代碼：

1. #include

2. #include

3. #include

4. #include

5. #include

6. #include

7. #include

8. #include

9. #include

10. #include

11. #include

12. #include

13. #define R register

14. #define LL longlong

15. #define pi 3.141

16. #define INF 1400000000

17. usingnamespace std;

18. 
    

19. class printData {

20. public:

21. void print(int number){

22. cout << number <<"n";

23. }

24. void print(double number){

25. cout << number <<"n";

26. }

27. void print(string s){

28. cout << s <<"n";

29. }

30. };

31. 
    

32. int main(){

33. printData test;

34. test.print(1);

35. test.print(1.1);

36. test.print("abcde");

37. return0;

38. }

通過上面的代碼，即使函數名相同，單數傳入的參數類型不同，那么程序調用的函數也不相同，程序的執行結果也不相同，這就是C++中的函數名重載。

C++中的運算符重載

在C++中額可以重載或重定義大多數的內置的運算符，這樣我們就可以使用自定義類型的運算符。

重載運算符的函數通常是帶有特殊函數名的函數，函數是由關鍵字operator和后面的運算符符合組成的，和普通函數相同，重載的運算符有一個返回類型和參數列表。

形式如下：

1. Boxoperator+(constBox&);

重載加法運算是用于將兩個Box類型的對象進行相加并最終返回Box類型的對象，大多數的重載運算符可以被定義為普通的非成員函數或者類內的成員函數，如果定義的函數是類的非成員函數，那么我們需要在每次執行函數的時候向函數內傳遞兩個參數，形式如下所示：

1. Boxoperator+(constBox&,constBox&);

下面的代碼通過使用成員函數進行了運算符重載，此時，對象作為參數進行傳遞，代碼如下所示：

1. #include

2. #include

3. #include

4. #include

5. #include

6. #include

7. #include

8. #include

9. #include

10. #include

11. #include

12. #include

13. #define R register

14. #define LL longlong

15. #define pi 3.141

16. #define INF 1400000000

17. usingnamespace std;

18. 
    

19. classBox{

20. private:

21. int length, breadth, height;

22. public:

23. int get_volume(){

24. return length * breadth * height;

25. }

26. void set_length(int l){

27. length = l;

28. }

29. void set_breadth(int b){

30. breadth = b;

31. }

32. void set_height(int h){

33. height = h;

34. }

35. Boxoperator+(Box& add_box){

36. Box box;

37. box.length = add_box.length + length, box.breadth = add_box.breadth + breadth, box.height = add_box.height + height;

38. return box;

39. }

40. };

41. 
    

42. int main(){

43. Box box1, box2, box3;

44. box1.set_length(1), box1.set_breadth(2), box1.set_height(3);

45. box2.set_length(4), box2.set_breadth(5), box2.set_height(6);

46. box3 = box1 + box2;

47. cout <<"The volume of box1 is: "<< box1.get_volume()<<"n";

48. cout <<"The volume of box2 is: "<< box2.get_volume()<<"n";

49. cout <<"The volume of box3 is: "<< box3.get_volume()<<"n";

50. return0;

51. }

可重載運算符/不可重載運算符

下面列出C++中可重載和不可重載的運算符。

可重載運算符：

不可重載運算符：

下面逐個對可重載的運算符進行演示。

一元運算符重載

一元運算符指的是只對一個操作數進行操作，下面是一元運算符的實例。

遞增運算符(++)，遞減運算符(--)

負號(-)

邏輯非運算符(!)

通常一元運算符出現在操作的對象的左邊，下面演示重載負號(-)一元運算符：

1. #include

2. #include

3. #include

4. #include

5. #include

6. #include

7. #include

8. #include

9. #include

10. #include

11. #include

12. #include

13. #define R register

14. #define LL longlong

15. #define pi 3.141

16. #define INF 1400000000

17. usingnamespace std;

18. 
    

19. classPoint{

20. private:

21. int x, y;

22. public:

23. Point(int x_x =0,int y_y =0){

24. x = x_x, y = y_y;

25. }

26. Pointoperator-(){

27. x =-x, y =-y;

28. return*this;

29. }

30. voidShow_Point(){

31. cout <<"("<< x <<","<< y <<")n";

32. }

33. };

34. 
    

35. int main(){

36. int x, y;

37. cin >> x >> y;

38. Point p(x, y);

39. -p;

40. p.Show_Point();

41. return0;

42. }

上面設計了一段求點關于原點對稱的點的代碼，重載了－運算符來直接對對象進行操作。

二元運算符重載

二元運算符主要需要兩個參數，我們通常使用的加(+)，減(-)，乘(*)，除(/)都是二元運算符。接下來我們嘗試重載 + 運算符：

1. #include

2. #include

3. #include

4. #include

5. #include

6. #include

7. #include

8. #include

9. #include

10. #include

11. #include

12. #include

13. #define R register

14. #define LL longlong

15. #define pi 3.141

16. #define INF 1400000000

17. usingnamespace std;

18. 
    

19. classBox{

20. private:

21. int length, breadth, height;

22. public:

23. int get_volume(){

24. return length * breadth * height;

25. }

26. void set_length(int l){

27. length = l;

28. }

29. void set_breadth(int b){

30. breadth = b;

31. }

32. void set_height(int h){

33. height = h;

34. }

35. Boxoperator+(Box& add_box){

36. Box box;

37. box.length = add_box.length + length, box.breadth = add_box.breadth + breadth, box.height = add_box.height + height;

38. return box;

39. }

40. };

41. 
    

42. int main(){

43. Box box1, box2, box3;

44. box1.set_length(1), box1.set_breadth(2), box1.set_height(3);

45. box2.set_length(4), box2.set_breadth(5), box2.set_height(6);

46. box3 = box1 + box2;

47. cout <<"The volume of box1 is: "<< box1.get_volume()<<"n";

48. cout <<"The volume of box2 is: "<< box2.get_volume()<<"n";

49. cout <<"The volume of box3 is: "<< box3.get_volume()<<"n";

50. return0;

51. }

接下來我們嘗試將上面的代碼進行改寫，將運算符重載的函數以非成員函數的方式進行重載運算符：

1. #include

2. #include

3. #include

4. #include

5. #include

6. #include

7. #include

8. #include

9. #include

10. #include

11. #include

12. #include

13. #define R register

14. #define LL longlong

15. #define pi 3.141

16. #define INF 1400000000

17. usingnamespace std;

18. 
    

19. classBox{

20. private:

21. int length, breadth, height;

22. public:

23. int get_volume(){

24. return length * breadth * height;

25. }

26. void set_length(int l){

27. length = l;

28. }

29. void set_breadth(int b){

30. breadth = b;

31. }

32. void set_height(int h){

33. height = h;

34. }

35. friendBoxoperator+(Box& add_box1,Box& add_box2);

36. };

37. Boxoperator+(Box& add_box1,Box&add_box2){

38. Box box;

39. box.length = add_box1.length + add_box2.length, box.breadth = add_box1.breadth + add_box2.breadth, box.height = add_box1.height + add_box2.height;

40. return box;

41. }

42. 
    

43. int main(){

44. Box box1, box2, box3;

45. box1.set_length(1), box1.set_breadth(2), box1.set_height(3);

46. box2.set_length(4), box2.set_breadth(5), box2.set_height(6);

47. box3 = box1 + box2;

48. cout <<"The volume of box1 is: "<< box1.get_volume()<<"n";

49. cout <<"The volume of box2 is: "<< box2.get_volume()<<"n";

50. cout <<"The volume of box3 is: "<< box3.get_volume()<<"n";

51. return0;

52. }

將重載函數作為非成員函數的時候，是將兩個對象進行相加，并且由于函數是全局函數，那么需要傳入的參數個數為2，同時當重載預算符的函數是全局函數的時候，需要在類中將這個函數聲明為友元函數。

關系運算符重載

C++支持很多種關系運算符，這些關系運算符用來比較C++中的數據類型，我們同時也可以重載任何一個關系運算符，接下來我們嘗試重載>，<，==關系運算符，從而實現一個成績排名的小程序：

1. #include

2. #include

3. #include

4. #include

5. #include

6. #include

7. #include

8. #include

9. #include

10. #include

11. #include

12. #include

13. #define R register

14. #define LL longlong

15. #define pi 3.141

16. #define INF 1400000000

17. usingnamespace std;

18. 
    

19. classStudent{

20. private:

21. string name, ID;

22. int score1, score2;

23. public:

24. Student(string n, string id,int number1,int number2){

25. name = n, ID = id, score1 = number1, score2 = number2;

26. }

27. Student(){

28. 
    

29. }

30. booloperator>(Student& s){

31. if(score1 + score2 > s.score1 + s.score2){

32. returntrue;

33. }

34. else{

35. returnfalse;

36. }

37. }

38. booloperator<(Student& s){

39. if(score1 + score2 < s.score1 + s.score2){

40. returntrue;

41. }

42. else{

43. returnfalse;

44. }

45. }

46. booloperator==(Student& s){

47. if(score1 + score2 == s.score1 + s.score2){

48. returntrue;

49. }

50. else{

51. returnfalse;

52. }

53. }

54. };

55. 
    

56. int main(){

57. string name, ID;

58. int score1, score2;

59. cin >> name >> ID >> score1 >> score2;

60. StudentStudent1(name, ID, score1, score2);

61. cin >> name >> ID >> score1 >> score2;

62. StudentStudent2(name, ID, score1, score2);

63. if(Student1>Student2){

64. cout <<"Student1 is better than Student2";

65. }

66. elseif(Student1==Student2){

67. cout <<"Student1 is equal to Student2";

68. }

69. elseif(Student1<Student2){

70. cout <<"Student1 is worse than Student2";

71. }

72. return0;

73. }

輸入輸出運算符重載

C++能夠使用流提取運算符>>和流插入運算符<<來進行輸入和輸出內置的數據類型，我們也可以重載流提取和插入運算符來操作對象或者我們自定義的數據類型。

通常我們會將輸入術后出的函數聲明為類的友元函數，這樣我們在使用的函數就不需要創建對象二直接調用函數。

下面我們將之前的對學生成績的代碼進行修改，添加了重載流提取運算符和流插入運算符的部分：

1. #include

2. #include

3. #include

4. #include

5. #include

6. #include

7. #include

8. #include

9. #include

10. #include

11. #include

12. #include

13. #define R register

14. #define LL longlong

15. #define pi 3.141

16. #define INF 1400000000

17. usingnamespace std;

18. 
    

19. classStudent{

20. private:

21. string name, ID;

22. int score1, score2;

23. public:

24. Student(string n, string id,int number1,int number2){

25. name = n, ID = id, score1 = number1, score2 = number2;

26. }

27. Student(){

28. 
    

29. }

30. booloperator>(Student& s){

31. if(score1 + score2 > s.score1 + s.score2){

32. returntrue;

33. }

34. else{

35. returnfalse;

36. }

37. }

38. booloperator<(Student& s){

39. if(score1 + score2 < s.score1 + s.score2){

40. returntrue;

41. }

42. else{

43. returnfalse;

44. }

45. }

46. booloperator==(Student& s){

47. if(score1 + score2 == s.score1 + s.score2){

48. returntrue;

49. }

50. else{

51. returnfalse;

52. }

53. }

54. friend istream &operator>>(istream& input,Student&student){

55. input >> student.name >> student.ID >> student.score1 >> student.score2;

56. return input;

57. }

58. friend ostream &operator<<(ostream& output,Student&student){

59. output <<"Student:"<< student.name <<" ID:"<< student.ID <<" total score:"<< student.score1 + student.score2 <<"n";

60. return output;

61. }

62. };

63. 
    

64. int main(){

65. string name, ID;

66. int score1, score2;

67. cin >> name >> ID >> score1 >> score2;

68. StudentStudent1(name, ID, score1, score2);

69. cin >> name >> ID >> score1 >> score2;

70. StudentStudent2(name, ID, score1, score2);

71. if(Student1>Student2){

72. cout <<"Student1 is better than Student2n";

73. }

74. elseif(Student1==Student2){

75. cout <<"Student1 is equal to Student2n";

76. }

77. elseif(Student1<Student2){

78. cout <<"Student1 is worse than Student2n";

79. }

80. cout <<Student1<<Student2;

81. return0;

82. }

上述代碼我們將流插入和提取運算符進行重載，可以直接對對象中的成員變量進行輸入和輸出。

通常我們輸入輸出習慣上使用cin>>和cout<<，這樣重載的時候需要使用友元函數來重載運算符，如果使用成員函數來重載運算符的時候將會出現d1<

++和--運算符重載

++和--運算符是C++中兩個重要的一元運算符，下面的示例中以時間變化為例演示重載++運算符的前綴和后綴的兩種用法：

1. #include

2. #include

3. #include

4. #include

5. #include

6. #include

7. #include

8. #include

9. #include

10. #include

11. #include

12. #include

13. #define R register

14. #define LL longlong

15. #define pi 3.141

16. #define INF 1400000000

17. usingnamespace std;

18. 
    

19. classTime{

20. private:

21. int hour, minute, second;

22. public:

23. Time(){

24. hour =0, minute =0, second =0;

25. }

26. Time(int h,int m,int s){

27. hour = h, minute = m, second = s;

28. }

29. friend ostream&operator<<(ostream& output,Time T){

30. output <<"The time is "<< T.hour <<":"<< T.minute <<":"<< T.second <<"n";

31. return output;

32. }

33. Timeoperator++(){

34. ++second;

35. if(second >=60){

36. ++minute;

37. minute -=60;

38. }

39. if(minute >=60){

40. ++hour;

41. minute -=60;

42. }

43. if(hour >=24){

44. hour =0;

45. }

46. return*this;

47. }

48. Timeoperator++(int){

49. ++second;

50. if(second >=60){

51. ++minute;

52. minute -=60;

53. }

54. if(minute >=60){

55. ++hour;

56. minute -=60;

57. }

58. if(hour >=24){

59. hour =0;

60. }

61. return*this;

62. }

63. };

64. 
    

65. int main(){

66. int hour, minute, second;

67. cin >> hour >> minute >> second;

68. Time T(hour, minute, second);

69. ++T;

70. cout << T;

71. T++;

72. cout << T;

73. return0;

74. }

遞增和遞減通常是改變對象的狀態，所以對遞增和遞減運算符的重載通常為成員函數。

重載遞增遞減一定要和指針的遞增和遞減進行區分，疑問這里的重載操作的是對象而不是指針（由于指針是內置類型，因此指針的遞增和遞減是無法被重載的），所以通常情況下的遞增和遞減操作的對象是對象內部的成員變量。

遞增和遞減運算符分為前置和后置兩種情況，因為符號相同，因此給后置的版本增加一個int類型的形參，這個形參為0，在函數體中式用不到的，引入這個形參只是為了區分富豪的前置和后置。

賦值運算符重載

和其他運算符相同，C++中允許我們重載賦值運算符，用來創建宇哥對象，比如拷貝構造函數。下面我們演示對賦值運算符的重載：

1. #include

2. #include

3. #include

4. #include

5. #include

6. #include

7. #include

8. #include

9. #include

10. #include

11. #include

12. #include

13. #define R register

14. #define LL longlong

15. #define pi 3.141

16. #define INF 1400000000

17. usingnamespace std;

18. 
    

19. classTime{

20. private:

21. int hour, minute, second;

22. public:

23. Time(){

24. hour =0, minute =0, second =0;

25. }

26. Time(int h,int m,int s){

27. hour = h, minute = m, second = s;

28. }

29. friend ostream&operator<<(ostream& output,Time T){

30. output <<"The time is "<< T.hour <<":"<< T.minute <<":"<< T.second <<"n";

31. return output;

32. }

33. Timeoperator=(Time& T){

34. hour = T.hour, minute = T.minute, second = T.second;

35. return*this;

36. }

37. };

38. 
    

39. int main(){

40. int hour, minute, second;

41. cin >> hour >> minute >> second;

42. Time T1(hour, minute, second);

43. Time T2;

44. T2 = T1;

45. cout << T1 << T2;

46. return0;

47. }

上述代碼通過將時間進行復制的操作演示了對賦值運算符的重載。

淺拷貝和隱式轉換：通常情況我們使用隱式轉換函數的時候十分謹慎，因為當我們不需要使用轉換蛤屬的時候，這個函數仍可能被調用執行，這些不正確的程序可能會出現一些意想不到的事情，而我們很難對此做出判斷，同時淺拷貝存在指針懸空的問題，所以我們通常禁止隱式轉換，在構造函數前面添加explicit關鍵字，通常情況下隱式轉換的聲明的意義不大，在實際情況中通常使用淺拷貝，不會調用隱式轉換。

函數調用運算符重載

蛤屬調用運算符可以被重載與類的對象，當我們重載()的時候，我們并不是調用了一種新的調用函數的方式，相反的這是創建了一個可以傳遞任意數目參數的運算符函數，下面我們通過求總秒數的例子來演示重載函數調用運算符：

1. #include

2. #include

3. #include

4. #include

5. #include

6. #include

7. #include

8. #include

9. #include

10. #include

11. #include

12. #include

13. #define R register

14. #define LL longlong

15. #define pi 3.141

16. #define INF 1400000000

17. usingnamespace std;

18. 
    

19. classTime{

20. private:

21. int hour, minute, second, total_second;

22. public:

23. Time(){

24. hour =0, minute =0, second =0, total_second =0;

25. }

26. Time(int h,int m,int s){

27. hour = h, minute = m, second = s, total_second =3600*24* hour +3600* minute + second;

28. }

29. void show_total_second(){

30. cout << total_second;

31. }

32. Timeoperator()(int h,int m,int s){

33. Time T;

34. T.total_second =24*60*60* h +60*60* m + s;

35. return T;

36. }

37. Timeoperator=(Time& T){

38. this->total_second = T.total_second;

39. return*this;

40. }

41. };

42. 
    

43. int main(){

44. int hour, minute, second;

45. cin >> hour >> minute >> second;

46. Time T1;

47. Time T2 = T1(hour, minute, second);

48. T2.show_total_second();

49. return0;

50. }

下標運算符[]重載

下標操作符[]通常用來訪問數組元素，重載這個運算符可以增強操作數組的功能，下面的代碼通過重載下標運算符來更方便得訪問類中數組指定的元素：

1. #include

2. #include

3. #include

4. #include

5. #include

6. #include

7. #include

8. #include

9. #include

10. #include

11. #include

12. #include

13. #define R register

14. #define LL longlong

15. #define pi 3.141

16. #define INF 1400000000

17. usingnamespace std;

18. 
    

19. classArray{

20. private:

21. int number[10], posion;

22. public:

23. int&operator[](int i){

24. return number[i];

25. }

26. Array(){

27. posion =0;

28. }

29. void set_value(int num){

30. number[posion]= num,++ posion;

31. }

32. };

33. 
    

34. int main(){

35. Array number;

36. for(R int i =0; i <10;++i){

37. int n;

38. cin >> n;

39. number.set_value(n);

40. }

41. for(R int i =0; i <10;++i){

42. cout << number[i]<<" ";

43. }

44. return0;

45. }

類成員訪問運算符（ -> ）可以被重載，但它較為麻煩。它被定義用于為一個類賦予"指針"行為。運算符 -> 必須是一個成員函數。如果使用了 -> 運算符，返回類型必須是指針或者是類的對象。

運算符 -> 通常與指針引用運算符 * 結合使用，用于實現"智能指針"的功能。這些指針是行為與正常指針相似的對象，唯一不同的是，當通過指針訪問對象時，它們會執行其他的任務。比如，當指針銷毀時，或者當指針指向另一個對象時，會自動刪除對象。

1. #include

2. #include

3. #include

4. #include

5. #include

6. #include

7. #include

8. #include

9. #include

10. #include

11. #include

12. #include

13. #define R register

14. #define LL longlong

15. #define pi 3.141

16. #define INF 1400000000

17. usingnamespace std;

18. 
    

19. // 假設一個實際的類

20. classObj{

21. staticint i, j;

22. public:

23. void f()const{ cout << i++<< endl;}

24. void g()const{ cout << j++<< endl;}

25. };

26. 
    

27. // 靜態成員定義

28. intObj::i =10;

29. intObj::j =12;

30. 
    

31. // 為上面的類實現一個容器

32. classObjContainer{

33. vector<Obj*> a;

34. public:

35. void add(Obj* obj)

36. {

37. a.push_back(obj);// 調用向量的標準方法

38. }

39. friendclassSmartPointer;

40. };

41. 
    

42. // 實現智能指針，用于訪問類 Obj 的成員

43. classSmartPointer{

44. ObjContainer oc;

45. int index;

46. public:

47. SmartPointer(ObjContainer& objc)

48. {

49. oc = objc;

50. index =0;

51. }

52. // 返回值表示列表結束

53. booloperator++()// 前綴版本

54. {

55. if(index >= oc.a.size()-1)returnfalse;

56. if(oc.a[++index]==0)returnfalse;

57. returntrue;

58. }

59. booloperator++(int)// 后綴版本

60. {

61. returnoperator++();

62. }

63. // 重載運算符 ->

64. Obj*operator->()const

65. {

66. if(!oc.a[index])

67. {

68. cout <<"Zero value";

69. return(Obj*)0;

70. }

71. return oc.a[index];

72. }

73. };

74. 
    

75. int main(){

76. constint sz =10;

77. Obj o[sz];

78. ObjContainer oc;

79. for(int i =0; i < sz; i++)

80. {

81. oc.add(&o[i]);

82. }

83. SmartPointer sp(oc);// 創建一個迭代器

84. do{

85. sp->f();// 智能指針調用

86. sp->g();

87. }while(sp++);

88. return0;

89. }

一些注意的要點

運算符重載不可以改變語法結構；

運算符重載不可以改變操作數的個數；

運算符重載不可以改變運算的優先級；

運算符重載不可以改變結合性。

類重載、覆蓋、重定義之間的區別：

重載指的是函數具有的不同的參數列表，而函數名相同的函數。重載要求參數列表必須不同，比如參數的類型不同、參數的個數不同、參數的順序不同。如果僅僅是函數的返回值不同是沒辦法重載的，因為重載要求參數列表必須不同。（發生在同一個類里）

覆蓋是存在類中，子類重寫從基類繼承過來的函數。被重寫的函數不能是static的。必須是virtual的。但是函數名、返回值、參數列表都必須和基類相同（發生在基類和子類）

重定義也叫做隱藏，子類重新定義父類中有相同名稱的非虛函數 ( 參數列表可以不同 ) 。（發生在基類和子類）

this 指針的作用

this 指針是一個隱含于每一個非靜態成員函數中的特殊指針。它指向正在被該成員函數操作的那個對象。當對一個對象調用成員函數時，編譯器先將對象的地址賦給 this 指針，然后調用成員函數，每次成員函數存取數據成員時由隱含使用 this 指針。