关于C++运算符重载和友元的概念

关于C++运算符重载和友元的概念

首先提供代码如下:

我们在头文件中定义了一个Time类

#pragma once
#ifndef TIME_H_
#define TIME_H_
#include "stdafx.h"
using namespace std;
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*(double n) const;
    void Show() const;
};
#endif

Time类的源文件代码如下:

#include "stdafx.h"
#include "Time.h"
#include <iostream>

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*(double mult) const
{
    Time result;
    long totalminutes = hours * mult * 60 + minutes * mult;
    result.hours = totalminutes / 60;
    result.minutes = totalminutes % 60;
    return result;
}

void Time::Show() const
{
    std::cout << hours << "hours," << minutes << "minutes";
}

测试函数(main)代码如下:

#include "stdafx.h"
#include "Time.h"
#include <iostream>
using namespace std;
void main()
{
    Time t1(4,35);
    Time t2(2, 47);
    Time adjusted;

    adjusted = t1 * 1.5;
    adjusted.Show();
    cout << endl;
}

运算符重载的概念
代码都在上面可以看,所以简单提一下.通过对*运算符的重载,我们可以直接把一个类的对象(adjusted)乘以一个double类型的值
adjusted = t1 * 1.5;
adjusted.Show();

问题提出
在前面的Time类实例中,重载的乘法运算符(*)将一个Time值与一个double结合.注意左侧的操作数是调用对象,也就是说,下面的语句A = B * 2.75;
将被隐式的转换为下面的成员函数调用A = B.operator(2.75);
那如果我们写成A = 2.75 * B;可以吗?答案是不行的,因为这种写法不对应于Time的成员函数.
我们想到一个解决方法:非成员函数
Time operator*(double m, Time &t);
但着引发了一个新问题:非成员函数不能直接访问私有数据,至少常规的成员函数不能访问.然而,有一类特殊的非成员函数可以访问类 的私有成员,它们被称为友元函数.

友元函数
我们在友元函数声明放在类声明中,并在原型声明前加上关键字friend
friend void operator<<(ostream & os,const Time &t);
定义如下:
Time operator*(double mult, Time &t)
{
Time result;
long totalminutes = t.hours * mult * 60 + t.minutes * mult;
result.hours = totalminutes / 60;
result.minutes = totalminutes % 60;
return result;
}
经过这样定以后我们就可以直接写出A = 2.75 * B的代码了

对于友元这里有几点需要注意的是

• 虽然operator运算符函数实在类中声明的,但它并不是类的成员函数,因此不能使用成员运算符来调用(.);
• 虽然operator运算符不是类成员函数,所以不要使用Time::域名限定符.另外,不要再定义中使用关键字friend.

重载<<运算符
假设trip是一个Time对象.为了显示Time的值,我们会用Show(),然而,我们如果像下面这样操作会更好:
cout << trip;
我们可以用ostream类来重新重载operator<<()定义

1.<<的第一个重载版本:

要是Time类使用cout,必须使用友元函数,我们可以现在Time类的头文件中声明友元函数

friend void operator<<(ostream & os,const Time &t);

在Time类的源文件中定义右元函数

void operator<<(ostream & os,const Time &t)
{
    os << t.hours << "hours," << t.minutes << "
}

这样就可以不用调用对象的Show()函数,而是直接输入代码cout<<adjustde<<endl;
通过对<<的重载就可以直接显示我们要的东西,而不需要调用函数了.

问题提出
以上实现不允许像通常那样重新定义的<<运算符与cout一起使用:
cout << "Trip Time:" << trip << "(TuesDay)\n";
那这时我们该怎么办?

2.<<的第一个重载版本:

我们可以对友元函数采用相同方法,只要修改operator<<()函数,让它返回ostream对象的引用即可
friend ostream & operator<<(ostream & os, const Time & t);

ostream & operator<<(ostream& os, const Time &t)
{
    os << t.hours << "hours," << t.minutes << "minutes";
    return os;
}

用过这样的方法我们就可以正确的使用代码cout << "Trip Time:" << trip << "(TuesDay)\n";