浅聊以下C++友元函数

目录

一、创建友元

二、友元函数的特点 

        1、一个函数可以是多个类的友元函数

        2、友元类中的成员函数都可以是另⼀个类的友元函数 

        3、友元类的关系是单向的

        4、友元类关系不能传递 

一、创建友元

        C++会控制类对象私有成员的访问。通常，在类中提供共有方法是唯一的访问途径，但是有时候这种限制太严格了，以致于会产生一些困扰。因此C++提供了⼀种突破类访问限定符封装的方式：友元

友元分为3种：

• 友元函数
• 友元类
• 友元成员函数

通过让函数成为类的友元，可以赋予该函数与类的成员函数有相同的权限

         示例：

class Test
{
	//声明友元函数
	friend void print(Test& t);
public:
	Test(int n = 1)
		:num(n)
	{
	}
private:
	int num;
};
void print(Test& t)
{
	cout << t.num << endl;
}

int main() 
{
	Test t = 100;
	print(t);
	return 0;
}

        结果：

        虽然成员变量【num】是【Test】类的私有成员变量，但是通过让函数【print】成为类的友元，可以赋予该函数与类的成员函数有相同的权限，因此可以直接访问私有成员变量【num】

二、友元函数的特点 

友元函数的特点：

1. 外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数
2. 友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制
3. ⼀个函数可以是多个类的友元函数
4. 友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员
5. 友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元
6. 友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是C的友元 

        1、一个函数可以是多个类的友元函数

        示例：

class B;
class A
{
	//一个函数可以是多个类的友元函数
	friend void print(A& a, B& b);
public:
	A(int n = 1)
		:_a(n)
	{}
private:
	int _a;
};

class B
{
	//一个函数可以是多个类的友元函数
	friend void print(A& a, B& b);
public:
	B(int n = 1)
		:_b(n)
	{}
private:
	int _b;
};

//一个函数可以是多个类的友元函数
void print(A& a, B& b)
{
	cout << a._a << " " << b._b << endl;
}

int main()
{
	A aa = 100;
	B bb = 200;
	print(aa, bb);
	return 0;
}

         结果：

        2、友元类中的成员函数都可以是另⼀个类的友元函数 

        示例： 

class B;
class A
{
	//友元类
	friend class B;
public:
	A(int n = 1)
		:_a(n)
	{}
private:
	int _a;
};

class B
{
public:
	B(int n = 1)
		:_b(n)
	{}
	//友元类中的成员函数都可以是另⼀个类的友元函数
	void print(A& a)
	{
		cout << a._a << " " << _b << endl;
	}
private:
	int _b;
};

int main()
{
	A aa = 100;
	B bb = 200;
	bb.print(aa);
	return 0;
}

        结果： 

        因为友元类中的成员函数都可以是另⼀个类的友元函数，所以【B】中的【print】函数是【A】的友元函数，与类的成员函数有相同的权限，因此可以直接访问私有成员变量【_a】

        3、友元类的关系是单向的

        示例：

class B;
class A
{
	//友元类
	friend class B;
public:
	A(int n = 1)
		:_a(n)
	{}
	//友元类的关系是单向的，不具有交换性
	void print(B& b)
	{
		cout << _a << " " << b._b << endl;
	}
private:
	int _a;
};

class B
{
public:
	B(int n = 1)
		:_b(n)
	{}
private:
	int _b;
};

        结果：

        【B】是【A】的友元类，但是【A】不是【B】的友元类，因此【A】中的函数不是【B】中的友元函数，不具有访问【B】类中私有成员权限 

        4、友元类关系不能传递 

        示例： 

class B;
class C;
class A
{
	//友元类
	friend class C;
public:
	A(int n = 1)
		:_a(n)
	{}
private:
	int _a;
};

class B
{
	//友元类
	friend class A;
public:
	B(int n = 1)
		:_b(n)
	{}
private:
	int _b;
};

class C
{
public:
	C(int n = 1)
		:_c(n)
	{}
	//友元类关系不能传递
	void print(B& b)
	{
		cout << b._b << endl;
	}
private:
	int _c;
};

         结果：

        【C】是【A】的友元类，【A】是【B】的友元类，但是友元类的关系不能传递因此【C】不是【B】的友元类，因此【C】中的函数不是【B】中的友元函数，不具有访问【B】类中私有成员权限 

三、小结

        友元有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用，因为友元机制允许非成员函数访问私有成员变量