友元（C++）

C++控制对象私有部分的访问。通常，公有类方法提供唯一的访问途径，但是有时候这种限制太严格，以致于不适合特定的编程问题。在这种情况下，C++提供了另外一种形式的访问权限：友元。友元有三种

• 友元函数
• 友元类
• 友元成员函数

通过让函数称为类的友元，可以赋予该函数与类的成员函数相同的访问权限。

介绍如何成为友元前，先介绍为何需要友元。再为类重载二元运算符时（带两个参数的运算符）常常需要友元。将Time对象乘以实数就属于这种情况。
在前面Time类示例中，重载的乘法运算符与其他两种重载运算符的差别在于，它使用了两种不同的类型。也就是说，加法和减法运算符都结合两个Time值，而乘法运算符将一个Time值与一个double值结合在一起。这限制了该运算符的使用方式。记住，左侧的操作数是调用对象。也就是说，下面的语句：

A = B * 2.75;

将被转换为下面的成员函数调用：

A = B.operator*(2.75);

但：

A = 2.75 * B;

这个表达式不对应于成员函数，因为2.75不是Time类型的对象。因此，编译器不能使用成员函数调用来替换该表达式。
解决这个难题的一种方式是，告知每个人，只能按B * 2.75这种格式编写，不能写成 2.75 * B。
然而，还有另一种解决方式——非成员函数。非成员函数不是由对象调用的，它使用的所有值（包括对象）都是显示参数。这样，编译器能够将下面的表达式：

A = 2.75 * B;

与下面的非成员函数调用匹配：

A = operator*(2.75, B);

该函数的原型如下：

Time operator*(double m, const Time & t);

对于非成员重载运算符函数来说，运算符表达式左边的操作数对应于运算符函数的第一个参数，运算符表达式右边的操作数对应于运算符函数的第二个参数。
但非成员函数不能直接访问类的私有数据，至少常规非成员函数不能访问。然而，有一类特殊的非成员函数可以访问类的私有成员，它们被称为友元函数。

创建友元：

创建友元函数的第一步是将其原型放在类声明中，并在原型声明前加上关键字friend：

friend Time operator*(double m, const Time &t)

该原型意味着下面两点：

• 虽然operator *()函数是再类声明中声明的，但它不是成员函数，因此不能使用成员运算符来调用；
• 虽然operator *()函数不是成员函数，但它与成员函数的访问权限相同。

第二步是编写函数定义。因为它不是成员函数，因此不要使用::限定符。另外，不要在定义中使用关键字friend，定义如下：

Time operator*(double m, const Time &t) {
	Time result;
	long totalminutes = t.hours*m * 60 + t.minutes * m;
	result.hours = totalminutes / 60;
	result.minutes = totalminutes % 60;
	return result;
}

有了上述声明和定义后，A = 2.75 * B 将转化为 A = operator*(2.75, B)。
总之，类的友元函数是非成员函数，其访问权限与成员函数相同。

实际上，按下面的方式对定义进行修改（交换乘法操作数的顺序），可以将这个友元函数编写为非友元函数：

Time operator*(double m, const Time &t) { return t * m };

原来的版本显式地访问t.minutes和t.hours，所以它必须是友元。这个版本将Time对象t作为一个整体使用，让成员函数来处理私有值，因此不必是友元。

常用的友元：重载<<运算符

假设trip是一个Time对象。为显示Time的值，前面使用的是Show()。然而，如果可以像下面这样操作将更好：

cout << trip;

cout是一个ostream对象，它是智能的，能够识别所有的C++基本类型。这是因为对于每种基本类型，ostream类声明中都包含了相应的重载的operator <<()定义。要使cout能够识别Time对象，一种方法是将一个新的函数运算符定义添加到ostream类声明中，但修改iostream文件是个危险的注意，这样做会在标准接口上浪费时间。相反，通过Time类声明来让Time类知道如何使用cout。

1. <<的第一种重载版本：
   要使Time类知道使用cout，必须使用友元函数。因为下面语句使用两个对象，第一个是ostream类对象cout：

cout << trip;

如果使用一个Time成员函数来重载<<，Time对象将是第一个操作数，就必须这么使用<<：

trip << cout;

因此使用友元函数：

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

新的Time声明使operator<<()函数成为Time类的一个友元函数。但该函数不是ostream类的友元，因为，该函数至始至终都将ostream对象作为一个整体使用。

另一个ostream对象是cerr，它将输出发送到标准输出流——默认为显示器，但在UNIX、Linux和Windows命令行环境中，可将标准错误流重定向到文件。另外，ofstream对象可用于将输出写入到文件中。通过继承ofstream对象可以使用ostream的方法。这样便可以用operator<<()定义来将Time的数据写入到文件和屏幕上，为此只需传递一个经过适当初始化的ofstream对象。

2. <<的第二种重载版本：
   前面介绍的实现存在一个问题，不允许像通常那样将重新定义的<<运算符与cout一起使用。

cout << "Trip time: " << trip << " (Tuesday)\n";

例如：

int x, =5, y = 8;
cout << x << y;

C++从左至右读取输出语句，意味着它等同于：

(cout << x) << y;

正如iostream中定义的那样，<<运算符要求左边是一个ostream对象。显然，因为cout是ostream对象，所以表达式cout << x满足这种要求。然而，因为表达式cout << x位于<<y的左侧，所以输出语句也要求该表达式是一个ostream类型的对象。因此，ostream类将operator <<()函数实现为返回一个指向ostream对象的引用。具体地说，它返回一个指向调用对象（这里是cout）的引用。因此，表达式（cout<<x）本身介绍ostream对象cout，从而可以位于<<运算符的左侧。
可以对友元函数采用相同的方法。只要修改operator<<()，让它返回ostream对象的引用即可：

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

注意，返回类型是ostream &。这意味着该函数返回ostream对象的引用。
因此，下述语句：

cout << "Trip time: " << trip << " (Tuesday)\n";

调用ostream中的<<定义，它显示字符串并返回cout对象：

cout << "Trip time: "

因此表达式cout << "Trip time: "将显示字符串，如何被它的返回值cout所替代。原来的语句被简化为：

cout << trip << " (Tuesday)\n";

接下来，程序使用<<的Time声明显示trip值，并再次返回cout对象，语句被简化为：

cout << " (Tuesday)\n";

现在，程序使用ostream中用于字符串的<<定义，来显示最后一个字符串，并结束运行。

这个operator<<()还可用于将输出写入到文件中：

#include<fstream>
...
ofstream fout;
fout.open("savetime.txt");
Time trip(12, 40);
fout << trip;

其中最后一条被转化为：

operator<<(fout, trip);

可以将Time类转化为（mytime0.h）：

#pragma once
#ifndef MYTIME0_H_
#define MYTIME0_H_

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 // !MYTIME0_H_

mytime0.cpp

#include<iostream>
#include"mytime0.h"
using namespace std;
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 %= 60;
	return sum;
}

Time Time::operator+(const Time &t) const {
	Time diff;
	int tot1, tot2;
	tot1 = t.minutes + 60 * t.hours;
	tot2 = minutes + 60 * hours;
	diff.minutes = (tot2 - tot1) % 60;
	diff.hours = (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;
}

Time operator*(double m, const Time &t) {
	Time result;
	long totalminutes = t.hours*m * 60 + t.minutes * m;
	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;
}

声明：以上整理自个人理解和Stephen Prata 著的《C++ Primer Plus》