前面提到过，在类的封装中，私有的成员变量和成员函数无法在类外访问，但是总有那么一些情况需要给类外的对象赋予一定的访问权限。比如在家里面，客厅是公共访问权限，而每个人的卧室是私有访问权限，对大多数人来说不可访问，但是自己的好朋友可以。同样的道理，在C++中实现这种功能需要借助友元的机制。简单来说就是如果某个类外的对象需要访问类内的私有成员，在类内声明为友元类型即可。

一、全局函数做友元

在本例中，首先构造了一个 house 类，需要在类内声明全局函数 Friend 为友元方能访问类内的私有成员：

class house
{
	friend void Friend(house& p_house);	// friend 是友元的关键字
public:
	string livingroom;
private:
	string bedroom;
public:
	house()		// 定义构造函数给成员变量赋值
	{
		livingroom = "客厅";
		bedroom = "卧室";
	}
};
void Friend(house& p_house)
{
	// 可以在类外正常访问类内的公有成员
	cout << "Friend 正在访问：" << p_house.livingroom << endl;
	// 将Friend函数声明为友元方可访问私有成员
	cout << "Friend 正在访问：" << p_house.bedroom << endl;
}
int main(void)
{
	house p;	// 实例化house对象
	Friend(p);	// 调用友元函数Friend
}

输出结果如下所示：

Friend 正在访问：客厅
Friend 正在访问：卧室

二、类做友元

想象一下，如果你某天需要出远门，需要一个朋友定期去你家里面进行打扫，这个时候你就需要给他一定的权限让他能够访问到家里面的任何地方。其实类做友元跟函数做友元一样，如下例所示：

class house{
    // 将 friend_house 类声明为house的友元后，该类实例化的对象能够访问 house 类对象的所有成员
	friend class friend_house;
public:
	string livingroom;
private:
	string bedroom;
public:
	house()		// 定义构造函数给成员变量赋值
	{
		livingroom = "客厅";
		bedroom = "卧室";
	}
	void show()	// 显示类内的变量内容
	{
		cout << "livingroom：" << livingroom << endl;
		cout << "bedroom：" << bedroom << endl;
	}
};
class friend_house{
public:
	void visit(house& p_House)
	{
		cout << "friend 正在访问：" << p_House.livingroom << endl;
        // 将类friend_house 声明为house的友元后，不仅可以访问house的公有成员，也能访问私有成员
		cout << "friend 正在访问：" << p_House.bedroom << endl;
		p_House.livingroom = "整理后的客厅";	// 由于传进来的参数是引用类型，可以修改原来house对象的值
		p_House.bedroom = "整理后的卧室";
	}
};
int main(void)
{
	house p;	// 实例化house对象
	friend_house p_friend;	// 
	p_friend.visit(p);	// 访问并修改house类对象p的成员
	p.show();
}

输出结果如下：

friend 正在访问：客厅
friend 正在访问：卧室
livingroom：整理后的客厅
bedroom：整理后的卧室

三、成员函数做友元

其实无论什么做友元都是一样的目的，只是友元的声明格式不同，比如：

1. 全局函数的声明：friend void Friend(house& p_house); // friend 是友元的关键字
2. 友元类的声明：friend class friend_house;
3. 成员函数的声明：friend void goodGay::visit1();

class Building;
class goodGay
{
public:
	goodGay();
	void visit1();
	void visit2();
 
private:
	Building * building;
};
//类内声明，类外实现；
class Building
{
	//让成员函数visit1做友元函数：
	friend void goodGay::visit1();
public:
	Building();
public:
	string m_sittingroom;	//客厅
private:
	string m_bedroom;		//卧室
};
Building::Building()
{
	this->m_bedroom = "卧室";
	this->m_sittingroom = "客厅";
}
goodGay::goodGay()
{
	building = new Building;
}
void goodGay::visit1()
{
	cout << "基友正在" << this->building->m_sittingroom << endl;
	//要访问私有属性的元素；
	//在Building 类中定义友元类：friend class goodGay;
	cout << "基友正在" << this->building->m_bedroom << endl;
 
}
void goodGay::visit2()
{
	cout << "基友正在" << this->building->m_sittingroom << endl;
	//要访问私有属性的元素；
	//在Building 类中定义友元类：friend class goodGay;
	//cout << "基友正在" << this->building->m_bedroom << endl;
}
int main()
{
	goodGay g1;
	g1.visit1();
	return 1;
}

输出结果为：

基友正在客厅
基友正在卧室