第11章 使用类——友元函数

本文章是作者根据史蒂芬·普拉达所著的《C++ Primer Plus》而整理出的读书笔记，如果您在浏览过程中发现了什么错误，烦请告知。另外，此书由浅入深，非常适合有C语言基础的人学习，感兴趣的朋友可以自行阅读此书籍。

友元

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

有3种形式的友元：

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

通常让函数称为类的友元，可以赋予该函数与类的成员函数相同的访问权限。下面主要介绍友元函数，其他两种友元将在第15章介绍。

为什么需要友元

在上一篇文中，我们实现了一个Time类，最后我们添加了个运算符重载函数，允许将Time类对象与一个doule类型的数据相乘。 调用时的写法是：

time_work = time_work * 5;

这实际上调用的是：

time_work = time_work.operator*(5);

问题来了，如果使用者不小心两个乘数写反了：

time_work = 5 * time_work;

5并没有这样一个重载函数，因此编译器就会报错。

对于使用者来说，这明显不符合乘法的交换律，但是可以从原理上解释的通：在运算符表示法中，运算符左侧的对象是调用对象，运算符右边的对象是作为参数被传递的对象。

而要解决这个问题的最好的方式是，使用非成员函数。非成员函数不是由对象调用的，它使用的所有值（包括对象）都是显示参数。

也就是说，上面的例子，我们希望可以这么做：

time_work = operator*(5，time_work);

函数原型如下：

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

将两者都作为参数传递到某个函数中，然后进行计算，再返回一个变量。

但是非成员函数不能直接访问类的私有数据，至少常规非成员函数不能访问。然而，有一类特殊的非成员函数可以访问类的私有成员成员，它们被称为友元函数。

创建友元函数

第一步，将函数原型放在类声明中，并在原型声明前加上关键字friend:

friend Time operator*(double m，const Time& t);

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

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

类的友元函数是非成员函数，其访问权限与成员函数相同。

应将友元函数看作类的扩展接口的组成部分。类方法和友元只是表达类接口的两种不同机制。

也可以使用下面的方法，将友元函数改为非友元函数。

Time operator*(double m，const Time& t)
{
  return t * m;  //调用原本的运算符重载函数
}

原本的方法显示的访问t.minutes和t.hours，所以它必须是友元。此版本将Time对象作为一个整体使用，让成员函数来处理私有值，因此不必是友元。但还是建议将该版本作为友元，最重要的是，它将该函数作为正式类接口的组成部分。其次，如果以后发现需要函数直接访问私有数据，则只要修改函数定义即可，而不必修改类原型。

如果要为类重载运算符，并将非类的项作为其第一个操作数，则可以用友元函数来反转操作数的顺序。

友元是否有悖于OOP

友元函数允许非成员函数访问私有数据，好像违反了OOP数据隐藏的原则。但实际上，应将友元函数看作类的扩展接口的组成部分。

例如，从概念上看，double 乘以Time和Time乘以double是完全相同的。也就是说，前一个要求有友元函数，后一个使用成员函数，这是C++句法的结果，而不是概念上的差别。通过使用友元方法和类方法，可以用同一个用户接口表达这两种操作。

另外请记住，只有类声明可以决定哪一个函数是友元，因此类声明仍然控制了哪些函数可以访问私有数据。总之，类方法和友元只是表达类接口的两种不同机制。

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

在上一章的Time类中，我们使用show()来显示Time类对象的值。但如果可以使用下面的操作会更好：

cout << time_work;

要使Time类可以使用cout，必须使用友元函数。那是因为上面的语句使用两个对象，第一个是ostream类对象(cout)。

在标准库中，cout是一个ostream对象，它能够识别所有的C++基本类型。这是因为对于每种基本类型，ostream类声明中都包含了相应的重载的operator<<()定义。

因此，要使cout能够识别Time对象，一种方法是将新的函数运算符定义添加到ostream类声明中。但修改iostream文件是个危险的主意，这样做会在标准接口上浪费时间。相反，通过Time类声明来让Time类知道如何使用cout。

另外，我们需要支持cout的一种常用写法，cout << time_morning << time_afternoon << time_evening，按照从左到右的执行顺序，cout << time_morning也应该返回一个cout对象，然后依次往后。

函数原型是：

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

函数实现如下，因为是友元函数，在实现时不可加friend，也不可加Time::作用域限定符：

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

接着，我们可以完善下Time类，主要是添加乘法运算符重载函数和<<运算符重载函数，另外我们就不需要专门的show()函数了。
类声明如下：

//mytime3.hpp
#ifndef _MYTIME0_HPP_
#define _MYTIME0_HPP_
#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 n, const Time& t)
  {
    return t * n;
  }
  friend std::ostream & operator<<(std::ostream &os, const Time& t);
};
#endif

类方法实现如下：

//mytime3.cpp
#include <iostream>
#include "mytime3.hpp"

Time::Time()
{
  hours = minutes = 0;
}

Time::Time(int h, int m)
{
  hours = h;
  minutes = m;
}

void Time::AddMin(int m)
{
  int total_minutes  = minutes + m;
  minutes = total_minutes % 60;
  hours += total_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 tmp;
  int total_minutes = t.minutes + minutes;
  tmp.minutes = total_minutes % 60;
  tmp.hours += hours + t.hours + total_minutes / 60;
  return tmp;
}
Time Time::operator-(const Time& t) const
{
  Time tmp;
  int result = (minutes + hours*60) - (t.minutes + t.hours*60);

  if (result > 0)
  {
    tmp.hours = result / 60;
    tmp.minutes = result % 60;
  }

  return tmp;
}

Time Time::operator*(double n) const
{
  Time tmp;
  int total_minutes = minutes + hours * 60;
  int result = total_minutes * n;
  tmp.hours = result / 60;
  tmp.minutes = result % 60;
  return tmp;
}

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

使用类：

//usetime3.cpp

#include <iostream>
#include "mytime3.hpp"

int main()
{
  using std::cout;
  using std::endl;
  
  Time time_work;
  Time time_work_morning(2, 35);
  Time time_work_afternoon(4, 40);

  cout << "morning work time: ";
  cout << time_work_morning;
  cout << endl;
  
  cout << "afternoon work time: ";
  cout << time_work_afternoon;
  cout << endl;
  
  Time time_work_evening(2, 30);
  cout << "evening work time: ";
  cout << time_work_evening;
  cout << endl;

  time_work = time_work_morning + time_work_afternoon+ time_work_evening;
  cout << "total time: ";
  cout << time_work;
  cout << endl;
  
  time_work = 5 * time_work;
  cout << "five days total time: ";
  cout << time_work;
  cout << endl;

  return 0;
}

程序运行结果如下：

morning work time: 2 hours, 35 minutes
afternoon work time: 4 hours, 40 minutes
evening work time: 2 hours, 30 minutes
total time: 9 hours, 45 minutes
five days total time: 48 hours, 45 minutes

重载运算符：作为成员函数还是非成员函数

对于很多运算符来说，可以选择使用成员函数或非成员函数来实现运算符重载，一般来说，非成员函数是友元函数，这样它才能访问类的私有数据。

有一个问题是，我们要选择使用哪种函数来实现运算符重载呢?

如Time类的加法运算符重载函数，我们既可以使用成员函数的方式来实现：

Time operator+(const Time & t) const;

也可以使用非成员函数的方式来实现：

friend Time operator+(const Time & t1, const Time & t2);

这两者的区别是，非成员函数的重载运算符函数所需的形参数目与运算符使用的操作数数目相同；而成员版本所需的参数数目少一个，因为其中的一个操作数是被隐式地传递的调用对象。

这两个原型都与表达式T2 + T3匹配，其中T2和T3都是Time类对象。

但是需要记住，在定义运算符时，必须选择其中的一种格式，而不能同时选择这两种格式。因为这两种格式都与同一个表达式匹配，同时定义这两种格式将被视为二义性错误，导致编译错误。

哪种格式更好呢？

对于某些运算符来说，使用成员函数是唯一合法的选择，如赋值运算符=，函数调用运算符()，下标运算符[]，通过指针访问类成员的运算符->。其它情况下，两者并无太大区别。有时，根据类设计，使用非成员函数版本可能更好(尤其是为类定义类型转换时)，后续我们继续学习"转换和友元"时再深入讨论此情形。