多态性：运算符重载为类的友元函数

       友元函数通过类的对象可以访问类的公有、保护和私有成员，也就是类的所有成员友元函数都能访问到。所以运算符重载为类的友元函数以后也可以访问类的所有成员。

       与运算符重载为成员函数时不同的是，重载的友元函数不属于任何类，运算符的操作数都需要通过函数的形参表传递。操作数在形参表中从左到右出现的顺序就是用运算符写表达式时操作数的顺序。

       这里也分双目运算符和单目运算符两种情况讨论运算符重载为友元函数的具体方式。

       如果有双目运算符U，它的其中一个操作数是类A的对象a，那么运算符U就可以重载为类A的友元函数，此友元函数的两个参数中，一个是类A的对象，另一个是其他对象，也可以是类A的对象。这样双目运算符重载为类的友元函数后，假设运算符的两一个操作数是对象b，则表达式a U b就相当于调用函数operator U(a, b)。

       下面再讨论单目运算符的重载。如果有前置单目运算符U，比如前置“--”，a为类A的对象，我们想实现U a这样的运算，就可以把U重载为类A的友元函数，此友元函数只有一个形参，为类A的对象，重载后表达式U a相当于调用函数operator U(a)。如果是后置单目运算符U，如后置“++”，a还是类A的对象，那么要实现a U这样的运算，也可以把U重载为类A的友元函数，此时友元函数就需要有两个形参，一个是类A的对象，另一个是整型形参，此整型形参没有实际意义，与前面后置单目运算符重载为成员函数时的整型形参一样，只是为了区分前置运算符和后置运算符的重载。重载后表达式a U就相当于调用函数operator U(a, 0)。

       将前面第一个例子中的运算符重载改为友元函数，再简单介绍下要实现的功能：时间值的加法，比如2个小时20分钟加3个小时30分钟，应该是5个小时50分钟，运算规则就是小时数相加，分钟数相加，如果分钟数的和超过60分钟则小时数再加1，分钟数减60。双目运算符“+”需要重载为时间值类的友元函数，此函数有两个形参，类型都是时间值类的对象。

1.   #include <iostream>
2.        using namespace std;
3.        class CTimeSpan
4.        {
5.        public:
6.                    CTimeSpan(int nHours=0, int nMins=0);      // 构造函数
7.                    friend CTimeSpan operator +(CTimeSpan ts1, CTimeSpan ts2); // 运算符“+”重载为成员函数
8.                    int GetHours()      { return m_nHours; }   // 获取小时数
9.                    int GetMins()       { return m_nMins; }    // 获取分钟数
10.                    void Show();                               // 显示时间值
11.        private:
12.                    int m_nHours;       // 小时数
13.                    int m_nMins;        // 分钟数
14.        };
15.        CTimeSpan::CTimeSpan(int nHours, int nMins)          // 构造函数的实现
16.        {
17.                   nHours += nMins/60;
18.                   nMins %= 60;
19.                   m_nHours = nHours;
20.                   m_nMins = nMins;
21.        }
22.        void CTimeSpan::Show()
23.        {
24.                  cout << m_nHours << "小时" << m_nMins << "分钟" << endl;
25.        }
26.        CTimeSpan operator +(CTimeSpan ts1, CTimeSpan ts2)  // 重载运算符函数实现
27.        {
28.                   int nNewHours;
29.                   int nNewMins;
30.                   nNewHours = ts1.m_nHours + ts2.m_nHours;
31.                   nNewMins = ts1.m_nMins + ts2.m_nMins;
32.                   nNewHours += nNewMins/60;
33.                   nNewMins %= 60;
34.                   return CTimeSpan(nNewHours, nNewMins);
35.        }
36.        int main()
37.        {
38.                  CTimeSpan timeSpan1(2, 50);
39.                  CTimeSpan timeSpan2(3, 30);
40.                  CTimeSpan timeSum;
41.                  cout << "timeSpan1: ";
42.                  timeSpan1.Show();
43.                  cout << "timeSpan2: ";
44.                  timeSpan2.Show();
45.                  timeSum = timeSpan1 + timeSpan2;
46.                  cout << "timeSum=timeSpan1+timeSpan2: ";
47.                  timeSum.Show();
48.                  return 0;
49.        }

       程序运行结果：

       timeSpan1: 2小时50分钟

       timeSpan2: 3小时30分钟

       timeSum=timeSpan1+timeSpan2: 6小时20分钟

       这个程序的主函数main与前面例子的main函数完全相同，程序运行结果也一样。区别就是加法运算符重载为CTimeSpan类的友元函数而不是成员函数，我们看到运算符重载函数有两个形参ts1和ts2，通过这两个参数将需要进行运算的操作数传递进去，而在此函数中也能够访问类CTimeSpan的私有成员m_nHours和m_nMins。