C++中友元【详细讲解】

1、友元的目的

在类中，有些保护属性或者私有属性也想让类外一些特殊的函数或者类进行访问，这就需要友元来帮忙。

友元的目的：就是让一个函数或者类可以访问另一个类中的私有成员（private）或者保护成员（protected）。【破坏了封装机制】

 2、友元函数

1）友元函数的概述

友元函数是指某些虽然【不是类成员函数】却能够通过类对象访问其所有成员【成员属性和成员函数】。类给予友元函数特别的访问权限。

2）友元函数的好坏

好处：可以提高编程的灵活性和程序执行效率；

坏处：破坏了类的封装机制。

3）友元函数的结构

【友元函数不是成员函数，而是类外的普通函数】

要使一个普通函数成为一个类的友元函数，必须在【这个类中进行声明】，使用friend进行修饰，格式如下：

friend 函数类型 函数名称(参数列表);

4）友元函数的分类

（1）全局函数作友元函数

#include <iostream>

using namespace std;
class Person {
public:
	//将全局函数声明为友元函数
	friend void fun(void);

private:
	int Age;
	int Data;
};
//全局函数的定义
void fun(void)
{
	Person a;   //通过类对象，实现对私有成员属性的访问和修改
	a.Age = 10;
	a.Data = 20;
	cout << "a.Age的值为：" << a.Age << endl;
	cout << "a.Data的值为：" << a.Data << endl;
}

int main()
{
	fun();
	return 0;
}

运行结果：

a.Age的值为：10
a.Data的值为：20

（2）类成员函数作友元函数

注意顺序：【类成员函数作友元时，需要注意友元声明和友元定义之间的互相依赖】

假设：类fun类中成员函数accessfun为类function的友元函数，其顺序如下：

a.首先是类function的声明【只有声明了类function才能进行定义友元函数】

b.其次是类fun的定义

c.最后是function的定义

程序：

#include <iostream>
#include <string>

using namespace std;

//类function的声明
class function;

//类fun的定义
class fun {
public:
	//成员函数的声明
	void accessfun(void);
};

//类function的定义
class function {
	//友元函数的声明
	friend void fun::accessfun(void);
public:
	//构造函数的定义
	function(int age, int data) :Age(age), Data(data)   //使用初始化列表进行初始化
	{
		cout << "调用了构造函数!!!" << endl;
	}
	//析构函数的定义
	~function()
	{
		cout << "调用了析构函数!!!" << endl;
	}
//私有成员属性
private:
	int Age;
	int Data;
};

//fun成员函数的定义
void fun::accessfun(void)
{
	function a(10,20);
	a.Age = 66;
	a.Data = 99;
	cout << "a.Age的值为：" << a.Age << endl;
	cout << "a.Data的值为：" << a.Data << endl;
}

int main()
{
	fun b;
	b.accessfun();
	return 0;
}

运行结果：

调用了构造函数!!!
a.Age的值为：66
a.Data的值为：99
调用了析构函数!!!

 3、友元类

1）友元类格式

友元类与友元函数类似，可以将一个类声明为另外一个类的友元类。若类fun为类function的友元类，则类fun的所有成员函数都是类function的友元函数。

格式：

class function
{
	public:
		friend class fun;
}

2）友元类的性质

友元类的所有成员函数都是另外一个类的友元函数，都可以访问另外一个类中的私有成员和保护成员。

3）程序

#include <iostream>

using namespace std;
class fun {
public:
	//普通成员函数声明
	void fun1(void);
	void fun2(void);
};

class function {
	//友元类的声明
	friend class fun;
public:
	//构造函数
	function(int age, int data):Age(age),Data(data)
	{
		cout << "调用了构造函数!!!" << endl;
	}
	//析构函数
	~function()
	{
		cout << "调用了析构函数!!!" << endl;
	}
private:
	int Age;
	int Data;
	//私有成员函数
	void function1(void)
	{
		cout << "调用了function1函数!!!" << endl;
	}
	//私有成员函数
	void function2(void)
	{
		cout << "调用了function2函数!!!" << endl;
	}
};
//普通成员函数的定义
void fun::fun1(void)
{
	function a(30, 40);
	cout << "a.Age的值为：" << a.Age << endl;
	cout << "a.Data的值为：" << a.Data << endl;
	a.function1();
}

//普通成员函数的定义
void fun::fun2(void)
{
	function a(66, 99);
	cout << "a.Age的值为：" << a.Age << endl;
	cout << "a.Data的值为：" << a.Data << endl;
	a.function2();
}
int main()
{
	fun b;
	b.fun1();
	cout << "-------------------------" << endl;
	b.fun2();
	return 0;
}

运行结果：

调用了构造函数!!!
a.Age的值为：30
a.Data的值为：40
调用了function1函数!!!
调用了析构函数!!!
-------------------------
调用了构造函数!!!
a.Age的值为：66
a.Data的值为：99
调用了function2函数!!!
调用了析构函数!!!