类的主要特点之一就是数据的封装，即类的私有成员无法在类的外部（作用域之外）进行访问。但是，有时需要在类的外部访问类的私有成员，怎么办？C++提供了另外一种形式的访问权限：友元。

1. 友元函数

创建友元函数

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

friend void operator(param1, param2 , ... );

该原型意味着两点：

• 虽然operator()函数是在类声明中声明的，但它不是成员函数，因此不能使用成员运算符来调用；
• 虽然operator()函数不是成员函数，但它与成员函数的访问权限相同（可访问对象任意成员属性，包括私有属性）。

#include<iostream>
#include<string>
using namespace std;

class TV{
public:
	friend void show(const TV &t); // 类内声明友元函数（friend关键字只出现在声明处）
	enum state_choice{OFF, ON};
	enum volume_range{MinVal=0, MaxVal=10};
	TV():state(OFF), volume(5){}
private:
	int state; // 开/关
	int volume; // 音量
};

void show(const TV &t){
	cout << "TV's state=" << t.state << "  TV's volume=" << t.volume << endl;
}


int main(){
	TV t;
	show(t);

	return 0;
}

输出：

TV's state=0  TV's volume=5

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

2. 友元类

电视：class TV

class TV{
public:
	friend class Remote; // 声明友元类，Remote可以访问TV的私有成员
	enum state_choice{OFF, ON};
	enum volume_range{MinVal=0, MaxVal=10};
	TV():state(OFF), volume(5){}
	void onOff(){ 
		state = (state == ON)?OFF:ON;
		cout << "电视 ";
		if(state == ON)
			cout << "已开启..." << endl;
		else
			cout << "已关闭..." << endl;
		
	}
	bool volUp(){
		if(volume < MaxVal){
			volume++;
			cout << "音量+1." << endl;
			return true;
		}else{
			cout << "您已达最大音量!" << endl;
			return false;
		}
	}
	bool volDown(){
		if(volume > MinVal){
			volume--;
			cout << "音量-1." << endl;
			return true;
		}else{
			cout << "您已达最小音量!" << endl;
			return false;
		}
	}
private:
	int state; // 开/关
	int volume; // 音量
};

遥控：class Remote

class Remote{
public:
	void onOff(TV &t){ t.onOff();}
	bool volUp(TV &t){
		if(t.state == 1){
			return t.volUp();
		}else{
			cout << "电视尚未开启,无法增减音量!" << endl;
			return false;
		}
	}
	bool volDown(TV &t){ 
		if(t.state == 1){
			return t.volDown();
		}else{
			cout << "电视尚未开启,无法增减音量!" << endl;
			return false;
		}
	}
	void show(TV &t){ 
		cout << "电视状态:" << t.state << "\t电视音量:" << t.volume << endl;
	}
};

使用：

int main(){
	TV t;
	Remote r;

	r.volUp(t);
	r.show(t);
	cout << endl;

	r.onOff(t);
	r.show(t);
	cout << endl;

	r.volUp(t);
	r.show(t);
	cout << endl;

	r.onOff(t);
	r.show(t);
    
	return 0;
}

输出：

电视尚未开启,无法增减音量!
电视状态:0      电视音量:5

电视 已开启...
电视状态:1      电视音量:5

音量+1.
电视状态:1      电视音量:6

电视 已关闭...
电视状态:0      电视音量:6

3. 友元成员函数

3.1 循环依赖

如果想让Remove的show方法称为TV类的友元成员函数：

class TV{
    friend void Remote::show(TV &t);
};

然而，要使编译器能够处理这条语句，它必须知道Remote的定义。否则，它无法知道Remote是一个类，而show是这个类的方法。这意味着应将Remote的定义放到TV的定义前面。而Remote的方法show中又提到了TV对象，这意味着TV类定义又要位于Remote定义之前，这就出现了循环依赖的情况。

3.2 解决循环依赖

避开这种循环依赖的方法是使用前向声明（forward declaration）。为此，需要在Remote定义的前面插入下面的语句：

class TV; 

这样，排列次序应如下：

class TV; // forward declaration
class Remote{...}；
class TV{...};

能否像下面这样排列呢？

class Remote; 
class TV{...};
class Remote{...}；

不能！

原因在于，编译器在TV类的声明中看到Remote的一个方法被声明为TV类的友元之前，应该先看到Remote类的声明和show()方法的声明。

还有一个问题尚需解决。那就是Remote的show方法中调用了TV的私有变量state和volume，这表明编译器此时必须已经看到了TV类的声明，这样才知道TV类中有哪些成员，但是TV类的声明又位于Remote之后，解决方法就是使Remote声明中只包含方法声明，具体的方法定义放在TV类之后。完整正确代码如下：

#include<iostream>
#include<string>
using namespace std;
class TV;

class Remote{
public:
	void show(TV &t);
};

class TV{
public:
	friend void Remote::show(TV &t); // 声明友元成员函数
	enum state_choice{OFF, ON};
	enum volume_range{MinVal=0, MaxVal=10};
	TV():state(OFF), volume(5){}
private:
	int state; // 开/关
	int volume; // 音量
};

void Remote::show(TV &t){ 
	cout << "电视状态:" << t.state << "\t电视音量:" << t.volume << endl;	
}


int main(){
	TV t;
	Remote r;

	r.show(t);

	return 0;
}

输出：

电视状态:0      电视音量:5

注意：让整个Remote类称为友元类并不需要前向声明，因为友元语句本身已经指出Remote是一个类：

friend class Remote;