?C++重載運算符和重載函數(shù)

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

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

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

a + b * c

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

add(a, multiply(b, c))

（假設運算符* 的優(yōu)先級高于運算符 +）

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

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

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

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

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

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

C++中的函數(shù)重載

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

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

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

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

C++中的運算符重載

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

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

形式如下：

1. Boxoperator+(constBox&);

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

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

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

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++中可重載和不可重載的運算符。

可重載運算符：

不可重載運算符：

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

一元運算符重載

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

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

負號(-)

邏輯非運算符(!)

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

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

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

二元運算符重載

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

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

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

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

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

關系運算符重載

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

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++能夠使用流提取運算符>>和流插入運算符<<來進行輸入和輸出內(nèi)置的數(shù)據(jù)類型，我們也可以重載流提取和插入運算符來操作對象或者我們自定義的數(shù)據(jù)類型。

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

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

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<<，這樣重載的時候需要使用友元函數(shù)來重載運算符，如果使用成員函數(shù)來重載運算符的時候將會出現(xiàn)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. }

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

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

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

賦值運算符重載

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

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

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

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

函數(shù)調(diào)用運算符重載

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

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

下標運算符[]重載

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

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

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

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

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. // 靜態(tài)成員定義

28. intObj::i =10;

29. intObj::j =12;

30. 
    

31. // 為上面的類實現(xiàn)一個容器

32. classObjContainer{

33. vector<Obj*> a;

34. public:

35. void add(Obj* obj)

36. {

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

38. }

39. friendclassSmartPointer;

40. };

41. 
    

42. // 實現(xiàn)智能指針，用于訪問類 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);// 創(chuàng)建一個迭代器

84. do{

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

86. sp->g();

87. }while(sp++);

88. return0;

89. }

一些注意的要點

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

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

運算符重載不可以改變運算的優(yōu)先級；

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

類重載、覆蓋、重定義之間的區(qū)別：

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

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

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

this 指針的作用

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