友元的位置关系

考虑如下一种场景：有一个电视机类Tv和一个遥控器类Remote，如何定义二者的关系呢？首先遥控器不能继承电视机，因为不是is-a关系；其次，遥控器也并非电视机的一部分，因此包含关系has-a也不适合。这时候将Remote类作为Tv类的友元类比较合适，使其能够使用Tv类的任何数据来控制电视机。但是如何定义两个类的位置关系呢？

首先是类的定义，稍后做出解释：

bt_友元类的位置关系.h

 1 #ifndef TV_ROMOTE_H
 2 #define TV_REMOTE_H
 3 #include <iostream>
 4 
 5 class Tv
 6 {
 7 public:
 8     friend class Remote;                      // 遥控器作为电视机的一个友元类
 9     enum{OFF, ON};                            // 电视机的开关状态
10     enum{MINVAL = 0, MAXVAL = 50};            // 电视机的音量范围
11     enum{MINCHANNEL = 1, MAXCHANNEL = 100};   // 电视机的频道范围
12 
13     Tv(int s = OFF, int v = 15) : state(s), volume(v), channel(1){ }
14     void onOff(){ state = (state == ON) ? OFF : ON; }   // 开关机
15     bool volumeUp();                 // 音量控制
16     bool volumeDown();
17     void channelUp();                // 频道控制
18     void channelDown();
19     void settings() const;           // 显示所有当前设置
20 
21 private:
22     int state;
23     int volume;
24     int channel;
25 };
26 bool Tv::volumeUp()
27 {
28     if(volume < MAXVAL)
29     {
30         volume++;
31         return true;
32     }
33     else
34         return false;
35 }
36 bool Tv::volumeDown()
37 {
38     if(volume > MINVAL)
39     {
40         volume--;
41         return true;
42     }
43     else
44         return false;
45 }
46 
47 void Tv::channelUp()
48 {
49     if(channel < MAXCHANNEL)
50         channel++;
51     else
52         channel = MINCHANNEL;    // 在最大频道时执行Up操作立即返回MINCHANNEL
53 }
54 void Tv::channelDown()
55 {
56     if(channel > MINCHANNEL)
57         channel--;
58     else
59         channel = MAXCHANNEL;   // 在最小频道时执行Down操作立即跳到MAXCHANNEL
60 }
61 
62 void Tv::settings() const
63 {
64     using std::cout;
65     using std::endl;
66     cout << "电视机当前状态为：" << (state == ON ? "开启" : "关闭") << endl;
67     cout << "当前音量设置为：" << volume << endl;
68     cout << "当前频道设置为：" << channel << endl;
69 }
70 
71 class Remote
72 {
73 public:
74     bool volumeUp(Tv& tv){ return tv.volumeUp(); }
75     bool volumeDown(Tv& tv){ return tv.volumeDown(); }
76     void onOff(Tv& tv){ tv.onOff(); }
77     void channelUp(Tv& tv){ tv.channelUp(); }
78     void channelDown(Tv& tv){ tv.channelDown(); }
79     void setChannel(Tv& tv, int chan);
80 };
81 void Remote::setChannel(Tv& tv, int chan)
82 {
83     tv.channel = chan;
84 }
85 
86 #endif // TV_ROMOTE_H

测试用例:

 1 #include "bt_友元类的位置关系.h"
 2 #include <iostream>
 3 
 4 int main()
 5 {
 6     using std::cout;
 7     using std::endl;
 8     Tv tv;                  // 实例化一台电视机
 9     tv.settings();
10 
11     cout << endl;
12     tv.onOff();             // 打开电视机
13     tv.settings();
14 
15     cout << endl;
16     Remote remote;          // 实例化一个遥控器
17     remote.volumeDown(tv);  // 用遥控器降低音量
18     remote.channelUp(tv);   // 用遥控器增加频道
19     remote.setChannel(tv, 10);  // 用遥控器切换到10频道
20     tv.settings();
21 
22     cout << endl;
23     remote.onOff(tv);       // 用遥控器关闭电视机
24     tv.settings();
25 
26     return 0;
27 }

如上所示，Tv的友元类必须定义在Tv类的后边，如果将Remote类的定义放在Tv类之前，那么由于友元类要使用Tv类的引用变量，那么此时编译器还没有看见过Tv类，造成编译失败。

仔细分析上边Remote的函数，大多数都是通过Tv类的公共接口实现的，就是说根本不需要友元类，一个普通类也可以实现，只有setChannel()函数是直接访问Tv类的私有成员的。因此，其实让Remote::setChannel()函数成为Tv类的友元函数即可，让其他函数保持普通函数的身份，那么此时又如何安排Tv类和Remote类的相对位置关系呢？

若如之前那样安排，就得如下表示：

class Tv

{

friend void Remote::setChannel(Tv& tv, int chan);

}

class Remote{ ... }

当编译器编译Tv类时，它无法明确得知Remote是一个类，因此出现“’Remote’ has not been declared”。而若此时将Remote类定义移到Tv类之前，又会出现Remote中引用的Tv未定义，此时为了避免这种循环依赖关系，可以使用前向声明(forward declaration)，如：

 1 class Tv;
 2 class Remote
 3 {
 4 public:
 5 bool volumeUp(Tv& tv);
 6 bool volumeDown(Tv& tv);
 7     void onOff(Tv& tv);
 8     void channelUp(Tv& tv);
 9     void channelDown(Tv& tv);
10     void setChannel(Tv& tv, int chan);
11 };
12 class Tv{ ... }
13 
14 void Remote::setChannel(Tv& tv, int chan)
15 {
16     tv.channel = chan;
17 }

注意：使用前向声明Tv时，Remote只能使用Tv来声明函数，而不能在定义中具体使用Tv的功能，因为在编译器看到完整的Tv类之前，是无法确定Tv中具体有什么的，因此，必须将Remote中引用Tv类的函数实现放到Tv类的定义后进行。

友元类和友元函数的示意图如下：

说明：使用友元类时不需要前向声明，因为友元语句(friend class Remote;)本身告诉编译器Remote是一个类，而使用友元函数时就需要把这一点补上。