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. };  
28.   
29. #endif  

mytime0.cpp

1. #include <iostream>   
2. #include "mytime0.h"   
3.   
4. Time::Time()  
5. {  
6.     hours = minutes = 0;  
7. }  
8.   
9. Time::Time(int h, int m)  
10. {  
11.     hours = h;  
12.     minutes = m;  
13. }  
14.   
15. void Time::AddMin(int m)  
16. {  
17.     minutes += m;  
18.     hours += minutes / 60;  
19.     minutes %= 60;  
20. }  
21.   
22. void Time::AddHr(int h)  
23. {  
24.     hours += h;  
25. }  
26.   
27. void Time::Reset(int h, int m)  
28. {  
29.     hours = h;  
30.     minutes = m;  
31. }  
32.   
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. }  
41.   
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. }  
51.   
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. }  
62.   
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. }  
71.   
72. std::ostream & operator<<(std::ostream & os, const Time & t)  
73. {  
74.     os << t.hours << "hours, " << t.minutes << " minutes";  
75.     return os;  
76. }  
77.   
78. void Time::Show()const  
79. {  
80.     std::cout << hours << " hours, " << minutes << " minutes";  
81.       
82. }  
83.   
84. //usetime0.cpp   
85. #include <iostream>   
86. #include "mytime0.h"   
87.   
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;  
96.   
97.     cout << "planning time = ";  
98.     planning.Show();  
99.     cout << endl;  
100.       
101.     cout << "coding time = ";  
102.     coding.Show();  
103.     cout << endl;  
104.   
105.     cout << "fixing time = ";  
106.     fixing.Show();  
107.     cout << endl;  
108.       
109. //  total = coding.Sum(fixing);   
110. //  重載加號運算符的版本   
111.     total = coding + fixing;  
112.     cout << "coding + fixing = ";  
113.     total.Show();  
114.     cout << endl;  
115.   
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;  
124.   
125.     Time aida(3, 35);  
126.     Time tosca(2, 48);  
127.     Time temp;  
128.   
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;  
136.   
137.     return 0;  
138. }  

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