本次博客 主要学习运算符重载和友元函数。其中
运算符重载能够将平时用于内置类型的变量的操作符(如+，-，*，/等)用于类对象；
友元这种C++机制使得非成员函数可以访问私有数据。
一、重载运算符
重载运算符，将普通运算符重载扩展到用户自定义类型，编译器根据具体环境来选用。（有点像重载函数—多态：函数名相同，但函数列表不同）这样做使代码看起来更加自然，同时隐藏了内部机理，强调了OOP的实质。
重载运算符，必须需要使用运算符函数的特殊函数格式，如下
operatorop(argument-list)
其中，op必须是有效的C++运算符。
重载运算符是怎样工作的？
理解重载运算符是怎样工作的？假定Time类，并为它定义一个operator+()成员函数，以重载+运算符，以便能够将两个Time类对象相加。等式：
T = t1 + t2 ;
编译器发现，操作数都是Time类对象，因此调用相应的运算符函数替换上述运算符：
T= t1. operator+( t2);
该函数隐式地使用了t1(因为它调用了方法)，而显式地使用t2对象（因为它被作为参数传递）。
因此，在运算符表示法中，运算符左侧的对象（这里为t1）是调用对象，运算符右边的对象（这里为t2）是作为参数被传递的对象。
扩展
当两个以上的对象相加时，如何转化为函数调用
T = t1 + t2 +t3;
由于+是从左向右的运算符，因此，
T= t1. operator+( t2+t3); //第一步
T= t1. operator+( t2. operator+(t3) );//第二步
二、友元函数的引入
在前面重载运算符的学习中，我们已经知道了，运算符左侧的操作数是调用对象，运算符右侧的操作数是参数。比如：
A = B * 2.75;
将被转换为下面的成员函数调用：
A = B.operator*(2.75);
可是下面的语句如何办呢？
A = 2.75 * B;
函数左侧是操作对象，而2.75不能作为操作对象，因此编译器不能使用成员函数调用来替换该表达式。
解决方案一：
告诉每个人只能用B*2.75这种格式写。显然这是一种对服务器友好，对客户需要当心的一种解决方案。
解决方案二：
对该重载运算符函数进行多态实现。
Time operator*(double m,const Time & t)
{
Return t * m; //use t.operator(m)
}
解决方案三：
引入友元函数的思想来解决。
1）首先将该函数修改非成员函数。
对于非成员重载运算符函数来说，运算符表达式左边的操作数对应于运算符函数的第一个参数，运算符表达式右边的操作数对应于运算符函数的第二个参数。
2）引入友元函数
因此，此时使用非成员函数按所需的顺序获得操作数，2.75作为函数第一个参数，B作为第二个参数。但引发一个新问题：普通非成员函数不能直接访问类的私有成员，然而，有一类特殊的非成员函数可以访问类的私有成员，它们被称为友元函数。
格式：
friend Time operator*(double m,const Time & t)
该原型意味着：
虽然operator*()函数是在类声明中声明的，但它不是成员函数，因此不能使用成员运算符来调用。虽然operator*()函数不是成员函数，但它与成员函数的访问权限相同。
总之，类的友元函数是非成员函数，其访问权限与成员函数相同。
注意，编写函数定义时，不能使用Time::限定符，不能加关键字friend。
三、代码部分
类的声明：
Time类提供了用于调整和重新设置时间、显示时间、将两个时间相加/减的方法； 构造函数； 友元函数的声明。
#ifndef MYTIME_H_
#define MYTIME_H_
#include <iostream>
class Time
{
private:
int hours;
int minutes;
public:
Time();
Time(
int h,
int m =
0);
void AddMin(
int m);
void AddHr(
int h);
void Reset(
int h =
0,
int m =
0);
Time
operator+(
const Time & t)
const;
Time
operator-(
const Time & t)
const;
Time
operator*(
double n)
const;
friend Time
operator*(
double m,
const Time & t)
{
return t * m ;}
friend std::ostream &
operator<<(
std::ostream &os,
const Time & t);
};
#endif
类的定义
#include "mytime.h"
Time::Time()
{
hours = minutes =
0;
}
Time::Time(
int h,
int m)
{
hours = h;
minutes = m;
}
void Time::AddMin(
int m)
{
minutes += m;
hours += minutes /
60;
minutes %=
60;
}
void Time::AddHr(
int h)
{
hours += h;
}
void Time::Reset(
int h,
int m)
{
hours = h;
minutes = m;
}
Time Time::
operator+(
const Time & t)
const
{
Time sum;
sum.minutes = minutes + t.minutes;
sum.hours = hours + t.hours + sum.minutes /
60;
sum.minutes = sum.minutes %
60;
return sum;
}
Time Time::
operator-(
const Time & t)
const
{
Time diff;
int tot1,tot2;
tot1 = t.minutes + t.hours *
60;
tot2 =minutes + hours *
60;
diff.hours = (tot2 -tot1) /
60;
diff.minutes = (tot2 -tot1) %
60;
return diff;
}
Time Time::
operator*(
double mult)
const
{
Time result;
long totalminutes = hours * mult *
60 +minutes *mult;
result.hours = totalminutes /
60;
result.minutes = totalminutes %
60;
return result;
}
std::ostream &
operator<<(
std::ostream & os,
const Time & t)
{
os << t.hours <<
" hours," << t.minutes <<
" minutes";
return os;
}
类的使用
#include "mytime.h"
#include <iostream>
int main()
{
using std::
cout;
using std::endl;
Time t1(
3,
35);
Time t2(
2,
48);
Time temp;
cout <<
"t1 and t2:\n";
cout << t1 <<
"; " <<t2 <<endl;
temp = t1 + t2;
cout <<
"t1+t2: "<<temp <<endl;
temp = t1 - t2;
cout <<
"t1-t2: "<<temp <<endl;
temp = t1 *
1.17;
cout <<
"t1*1.17: "<<temp <<endl;
temp =
1.17 * t1;
cout <<
"1.17*t1: "<<temp <<endl;
cout <<
"10.0*t1: " <<
10.0*t1<<
"10.0*t2: " <<
10.0*t2<<endl;
return 0;
}
截图：
注意：
1. 当总的分钟数超过59时，函数是通过整数除法和求模运算调整minutes和hours的值的。
2. 函数的参数是引用传递，目的是提高效率。传值也能实现，但是传递引用速度更快，使用的内存更少。
3. 函数的返回值不能是引用。返回对象将创建对象的副本，函数结束时虽然销毁了局部变量，而调用函数使用的是所构造的副本。然而，如果返回类型为引用，由于局部变量在函数结束时被删除，因此引用将指向一个不存在的对象。
因此，不要返回指向局部变量/临时对象的引用。函数执行完毕后，局部变量和临时对象将消失，引用将指向不存在的数据。
