C++之友元

一、友元类
    类并非只能拥有友元函数，也可以将类作为友元；但什么时候会希望一个类称为另一个类的友元呢，我们来看一个例子，如果要编写一个模拟电视机和遥控器的简单程序，决定定义一个Tv类和Remote类，来分别表示电视机和遥控器。很明显，遥控器可以改变电视机的状态，这表明应将Romote类作为Tv类的一个友元。

首先来定义一组状态成员来表示电视机，下面是一些可能的状态：
1.开/关
2.频道设置
3.音量设置
4.有线电视或天线调节模式
5.TV调谐或A/V输入
另外，很多遥控器都有两种工作模式--用作电视控制器和VCR遥控器。
因此，定义类如下：
由于Remote类提到了Tv类，所以编译器必须了解Tv类后，才能出来Remote类。为此，最简单的方法是首先定义Tv类。

tv.h

#ifndef TV_H_
#define TV_H_

class Tv
{
    public:
	friend class Remote;
	enum {Off, On};
        enum {MinVal, MaVal = 20};
	enum {Antenna, Cable};
	enum {TV, VCR};

	Tv (int s = Off, int mc = 100):state(s),volume(5),
		maxchannel(mc),channel(2),mode(Cable),input(TV){}
	void onoff(){state = (state == On) ? Off:On;}
	bool ison()const{return state == On;}
	bool volup();
	bool voldown();
	void chanup();
	void chandown();
	void set_mode() {mode = (mode == Antenna) ? Cable: Antenna;}
	void set_input() {input = (input == TV) ? VCR : TV;}
	void settings() const;
    private:
	int state;
	int volume;
	int maxchannel;
	int channel;
<span style="white-space:pre">	</span>int mode;
	int input;
};

class Remote
{
    private:
	int mode;
    public:
	Remote(int m = Tv::TV):mode(m){}
        bool volup(Tv & t){return t.volup();}
	bool voldown(Tv & t){return t.voldown();}
	void onoff(Tv & t){t.onoff();}
	void chanup(Tv & t){t.chanup();}
	void chandown(Tv & t){t.chandown();}
	void set_chan(Tv & t, int c){t.channel = c;}
	void set_mode(Tv & t){t.set_mode();}
	void set_input(Tv & t){t.set_input();}
};
#endif

tv.cpp

#include <iostream>
#include "tv.h"

bool Tv::volup()
{
    if (volume < MaVal)
    {
        volume++;
	return true;
    }
    else
	return true;
}

bool Tv::voldown()
{
    if (volume > MinVal)
    {
        volume--;
	return true;
    }
    else
	return false;
}

void Tv::chanup()
{
    if (channel < maxchannel)
	channel++;
    else
	channel = 1;
}

void Tv::chandown()
{
    if (channel > 1)
	channel--;
    else
	channel = maxchannel;
}

void Tv::settings()const
{
    using std::cout;
    using std::endl;
    cout << "TV is " << (state == Off ? "Off" : "On") << endl;
    if (state == On)
    {
        cout << "Volume setting = " << volume << endl;
	cout << "Channel setting = " << channel<< endl;
	cout << "mode = " << (mode == Antenna ? "antenna" : "cable")  << endl;
	cout << "input = " << (input == TV ? "TV":"VCR")  << endl;
    }
}

use_tv.cpp

#include <iostream>
#include "tv.h"

int main()
{
    using std::cout;
    Tv s27;
    cout << "Initial settings for 27\" TV:\n";
    s27.settings();
    s27.onoff();
    s27.chanup();
    cout << "\nAdjusted settings for 27\"TV:\n";
    s27.settings();

    Remote grey;

    grey.set_chan(s27, 10);
    grey.volup(s27);
    grey.volup(s27);
    cout << "\n27\" settings after using remote:\n";
    s27.settings();

    Tv s32(Tv::On);
    s32.set_mode();
    grey.set_chan(s32, 28);
    cout << "\n32\"settings:\n";
    s32.settings();

    return 0;
}

二、友元成员函数
从上面的例子可知，大多数Remote方法都是用Tv类的公有接口实现的；这意味着这些方法不是真正需要作为友元，事实上，唯一直接访问Tv成员的Remote方法是Remote::set_chan(),因此，它是唯一需要作为友元的方法。不过这样做有点麻烦，必须小心的排列各种声明和定义的顺序。因为：让Remote::set_chan()成为Tv类的友元的方法是，在Tv类声明中将其声明为友元：

class Tv
{
    friend void Remote::set_chan(Tv & t,int c);
	...
}

不过要使编译器能够处理这条语句，它必须知道Remote的定义，否则，它无法知道Remote是一个类，而set_chan是这个类的方法，这意味着应将Remote的定义放到Tv的定义前面，但Remote的方法提到了Tv对象，而这意味着Tv定义应当位于Remote定义之前，避开这种循环依赖的方法是，使用前向声明。为此，要在Remote定义的前面插入下面的语句：排列次序应如下：

class Tv;
class Remote
{

};
class Tv
{

};

能否像下面这样排列呢？不能！！！

class Remote;
class Tv{};
class Remote{};

因为在编译器Tv类的声明中看到Remote的一个方法被声明为Tv类的友元之前，应该先看到Remote类的声明和set_chan方法的声明。
三、嵌套类
在C++中，可以将类声明放在另一个类中，在另一个类中声明的类被称为嵌套类，包含类的成员函数可以创建和使用被嵌套类的对象；而仅当声明位于公有部分，才能在包含类的外面使用嵌套类，而且必须使用作用域解析操作符。