C++中使用類（重載，友元函數，轉換函數等）

說下C++裡的操作符重載和以後的內容。C++中有個operator操作符概念。如果想重載+運算符，那麼需要寫成operator+()。一般兩個數相加是這麼調用的：

1. a = b+c; == a = b.operator+(c);

當調用操作符，會有一個隱式的調用。把自己的對象作為操作符的對象。然後顯示調用參數c。

重點介紹友元函數。因為重載了運算符後可能出現類似：

1. a = 1.5 + c;

此時按照上面的說法。1.5不是一個對象。無法完成操作，這時候就需要友元函數了，其實友元函數就是類的非成員函數，不會隱式的將自身對象也作為參數。

然後貼三段代碼，注釋寫的還算詳細。大家可以復制後去運行下看下結果。代碼是從C++Primer Plus裡抄過來的。

mytime0.h

1. #ifndef MYTIME0_H_
2. #define MYTIME0_H_
3. #include <iostream>
4. class Time
5. {
6. private:
7. int hours;
8. int minutes;
9. public:
10. Time();
11. Time(int h, int m = 0);
12. void AddMin(int m);
13. void AddHr(int h);
14. void Reset(int h = 0, int m = 0);
15. Time Sum(const Time & t)const;
16. // 接下來時重載+運算符的函數
17. Time operator+(const Time & t)const;
18. void Show()const;
19. // 重載-運算符的函數
20. Time operator-(const Time & t)const;
21. // 重載*運算符的函數
22. Time operator*(double n)const;
23. // 友元函數 類似 a+b 的原型是 a.operator+(b); 所以如果 5*a 則5沒有那個重載的函數，這時就不能使用類的成員函數了，需要友元函數來進行操作，類友元函數也就是非成員函數
24. friend Time operator*(double m, const Time & t){return t * m;} //內聯函數，調用該類的成員函數，這裡也就是上面那個函數。
25. // 友元函數。對於那些非成員重載操作符函數來說，操作符左面的操作數對應函數的第一個參數。類似 c = a+b 類似於 c = operator+(a,b)
26. friend std::ostream & operator<<(std::ostream & os, const Time & t);
27. };
29. #endif

mytime0.cpp

1. #include <iostream>
2. #include "mytime0.h"
4. Time::Time()
5. {
6. hours = minutes = 0;
7. }
9. Time::Time(int h, int m)
10. {
11. hours = h;
12. minutes = m;
13. }
15. void Time::AddMin(int m)
16. {
17. minutes += m;
18. hours += minutes / 60;
19. minutes %= 60;
20. }
22. void Time::AddHr(int h)
23. {
24. hours += h;
25. }
27. void Time::Reset(int h, int m)
28. {
29. hours = h;
30. minutes = m;
31. }
33. Time Time::Sum(const Time & t)const
34. {
35. Time sum;
36. sum.minutes = minutes + t.minutes;
37. sum.hours = hours + t.hours + sum.minutes/60;
38. sum.minutes %= 60;
39. return sum;
40. }
42. // 重載加號運算符的版本
43. Time Time::operator+(const Time & t)const
44. {
45. Time sum;
46. sum.minutes = minutes + t.minutes;
47. sum.hours = hours + t.hours + sum.minutes/60;
48. sum.minutes %= 60;
49. return sum;
50. }
52. Time Time::operator-(const Time & t)const
53. {
54. Time diff;
55. int tot1, tot2;
56. tot1 = t.minutes + 60 * t.hours;
57. tot2 = minutes + 60 * hours;
58. diff.minutes = (tot2 - tot1) % 60;
59. diff.hours = (tot2 - tot1) / 60;
60. return diff;
61. }
63. Time Time::operator*(double n)const
64. {
65. Time result;
66. long totalminutes = hours * n * 60 + minutes * n;
67. result.hours = totalminutes / 60;
68. result.minutes = totalminutes % 60;
69. return result;
70. }
72. std::ostream & operator<<(std::ostream & os, const Time & t)
73. {
74. os << t.hours << "hours, " << t.minutes << " minutes";
75. return os;
76. }
78. void Time::Show()const
79. {
80. std::cout << hours << " hours, " << minutes << " minutes";
82. }
84. //usetime0.cpp
85. #include <iostream>
86. #include "mytime0.h"
88. int main()
89. {
90. using std::cout;
91. using std::endl;
92. Time planning;
93. Time coding(2, 40);
94. Time fixing(5, 55);
95. Time total;
97. cout << "planning time = ";
98. planning.Show();
99. cout << endl;
101. cout << "coding time = ";
102. coding.Show();
103. cout << endl;
105. cout << "fixing time = ";
106. fixing.Show();
107. cout << endl;
109. // total = coding.Sum(fixing);
110. // 重載加號運算符的版本
111. total = coding + fixing;
112. cout << "coding + fixing = ";
113. total.Show();
114. cout << endl;
116. Time morefixing(3 ,20);
117. cout << "more fixing time = ";
118. morefixing.Show();
119. cout << endl;
120. total = morefixing.operator+(total);
121. cout << "morefixing.operator+(total) = ";
122. total.Show();
123. cout << endl;
125. Time aida(3, 35);
126. Time tosca(2, 48);
127. Time temp;
129. cout << "Aida and TOsca:\n";
130. cout << aida <<"; " << tosca << endl;
131. temp = aida + tosca; // operator+()
132. cout << "Aida + Tosca: " << temp << endl;
133. temp = aida*1.17;
134. cout << "Aida *1.17: " << temp << endl;
135. cout << "10 * Tosca: " << 10 * tosca << endl;
137. return 0;
138. }

然後接下來說下類的強制轉換和自動轉換。