友元

类并非只能拥有友元函数，也可以将类作为友元。在这种情况下，友元类的所有方法都可以访问原始类的私有成员和保护成员。因此尽管友元被授予从外部访问类的私有部分的权限，但它们并不与面向对象的编程思想相悖，相反提高了共有接口的灵活性。

友元类 

假定需要编写一个模拟电视机和遥控器的简单程序，定义两个类Tv和Remote类。遥控器可以改变电视机的状态，这表明Remote类作为Tv类的一个友元

首先定义Tv类。可以用一组状态成员（描述电视各个方面的变量）来表示电视机：

• 开、关
• 频道设置
• 音量设置
• 有线电视或天线调节模式
• TV协调或A/V输入 

下面的语句使得Remote成为友元类：

friend class Remote;

 友元声明可以位于公有、私有或保护部分，其所在的位置无关紧要。

tv.h 

#ifndef TV_H_
#define TV_H_

class Tv 
{
public:
	friend class Remote;	//Remote can access Tv private parts
	enum{Off,On};
	enum{MinVal,MaxVal=20};
	enum{Antenna,Cable};
	enum{TV,DVD};

	Tv(int s=Off,int mc=125):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) ? DVD : TV; }
	void settings()const;	//display all settings

private:
	int state;	//on or off
	int volume;	//assumed to be digitized
	int maxchannel;	//maximum number of channels
	int channel;	//current channel setting
	int mode;	//broadcast or cable
	int input;	//TV or DVD
};

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_H_

除构造函数外，所有的Remote方法都将一个Tv对象引用作为参数，这表明遥控器必须针对特定的电视机

tv.cpp

#include<iostream>
#include"tv.h"
bool Tv::volup()
{
	if (volume < MaxVal)
	{
		volume++;
		return true;
	}
	else
		return false;
}
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" : "DVD") << endl;
	}
}

use_tv.cpp

#include<iostream>
#include"tv.h"
int main()
{
	using std::cout;
	Tv s42;
	cout << "Initial setting for 42\"TV:\n";
	s42.settings();
	s42.onoff();
	s42.chanup();
	cout << "\nAdjusted setting for 42\"TV:\n";
	s42.settings();

	Remote grey;
	grey.set_chan(s42, 10);
	grey.volup(s42);
	grey.volup(s42);
	cout << "\n42\"setting after using remote:\n";
	s42.settings();

	Tv s58(Tv::On);
	s58.set_mode();
	grey.set_chan(s58, 28);
	cout<<"\n58\"setting:\n";
	s58.settings();
	return 0;
}

 

 友元成员函数

在上一个例子的代码中，大多数Remote方法都是用Tv类的公有接口实现的。这意味着这些方法不是真正需要作为友元。 事实上，唯一直接访问Tv成员的Remote方法是Remote::set_chan(),因此它是唯一需要作为友元的方法。确实可以选择仅让特定的类成员成为另一个类的友元，而不必让整个类成为友元。

但是这样做必须小心排列各种声明和定义的顺序。

让Remote::set_chan()成为Tv类的友元的方法是，在Tv类声明中将其声明为友元

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

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

class Tv;    //forward declaration
class Remote {...};
class Tv {...};

 RTTI（Runtime Type  Identification，运行阶段类型识别）

C++有3个支持RTTI的元素。（RTTI只适用于包含虚函数的类）

• 如果可能的话，dynamic_cast运算符将使用一个指向基类的指针来生成一个指向派生类的指针；否则该运算符返回0——空指针
• typeid运算符返回一个指出对象的类型的值
• type_info结构存储了有关特定类型的信息