C++语法学习笔记十六：友元函数-友元类-友元成员函数

实例代码：

#include <iostream>
#include <string>
#include <vector>

using namespace std;


//基类

//类定义/ 类声明
class Human{
public:
	Human(){
		std::cout << " 执行了Human::Human() " << std::endl;
	}

	Human(int abc){
		std::cout << " 执行了Human::Human(int) " << std::endl;
	}

	virtual ~Human(){

	}
	void funcpub(){
		std::cout << " 执行了Human::funcpub() " << std::endl;
	}

	void somenamefunc(){
		std::cout << " 执行了Human::somenamefunc() " << std::endl;
	}

	void funchuman(){
		std::cout << " 执行了Human::funchuman() " << std::endl;
	}

	//声明成虚函数
	virtual void eat(){
		std::cout << " 人类吃各种粮食 " << std::endl;
	}

public:
	int m_age; //年龄
	char m_name[100]; //名字

}; // 类定义/ 类声明时 大家千万不要忘记末尾的;


//子类

//男人
class Men : public Human{  //表示Men 是Human的子类
public:
	Men(){
		std::cout << " 执行了Men::Men() " << std::endl;
	}

	Men(int abc){
		std::cout << " 执行了Men::Men(int) " << std::endl;
	}

	void somenamefunc(){

		Human::somenamefunc(); //调用父类somenamefunc函数
		std::cout << " 执行了Men::somenamefunc() " << std::endl;
	}

	virtual void eat(){
		std::cout << " 男人喜欢吃米饭 " << std::endl;
	}

	//因为友元函数不属于类成员，所以友元函数声明不受public ,protected, private;
	friend void func(const Men& tempmen); //该函数是友元函数

private:
	void funcmen()const {
		std::cout << " 执行了Men::funcmen() " << std::endl;
	}
	//virtual void eat2() = 0; //纯虚函数，没有函数体，只有一个函数声明

public:
	using Human::somenamefunc;

};

//女人
class WoMen : public Human{  //表示Men 是Human的子类
public:
	WoMen(){
		std::cout << " 执行了WoMen::WoMen() " << std::endl;
	}

	WoMen(int abc){
		std::cout << " 执行了WoMen::WoMen(int) " << std::endl;
	}

	void somenamefunc(){
		Human::somenamefunc(); //调用父类somenamefunc函数
		std::cout << " 执行了WoMen::somenamefunc() " << std::endl;
	}

	void funcmen(){
		std::cout << " 执行了WoMen::funcmen() " << std::endl;
	}

	virtual void eat(){
		std::cout << " 女人喜欢吃面食 " << std::endl;
	}

public:
	using Human::somenamefunc;

};


void func(const Men & tmpmen){
	tmpmen.funcmen();
}



class A{
private: 
	int data;

	friend class C; // 这就是友元的声明,虽然此时类C没有定义，但是系统没报错；
};


class B;

class C{
public:
	void callCAF(int x, A& a){
		a.data = x; //正常情况下这个不行
		cout << a.data << endl;
	}

	void callCAF2(A &a){
		a.data;
	}
	void callCAFB(int x, B& b){
		//b.data = x; //正常情况下这个不行
		//cout << b.data << endl;
	}
};

class B{
private:
	int data;

	friend void C::callCAFB(int x, B &a); // 该函数是友元成员函数的声明
};



int main() {

	//一、友元函数 这是个函数
	//只要让函数func成为类Men的友元函数，那么func这个函数就能够访问类Men的所有成员（成员变量，成员函数）
	//private, protected, public 
	Men men;
	func(men); //"test"

	//总结：友元函数func(....)： 是个函数，通过声明为某个类Men的友元函数，它就能访问这个类（Men）的所有成员
	//包括private, protected, public 


	//二、友元类：类 可以把其他的类 定义成友元类，如果你是我的友元类，那么你 就可以在你的成员函数中访问
	//我的所有成员，包括private, protected, public 
	//我们修改类A, 让类C成为类A的朋友（也就是让类C成为类A的友元类）；

	A a;
	C c;
	c.callCAF(3, a);

	//注意：每个类都负责控制自己的友元类和友元函数，所以：
	//a) 友元关系不能被继承
	//b) 友元关系是单向的，比如上边类C是类A的友元类， 但这并不表示类A是类C的友元类；
	//c) 友元关系没有传递性的，比如类B是类A的友元类，类C是类B的友元类，这并不代表类C是类A的友元类。
	
	//三、友元成员函数
	//写这种友元成员函数，必须要注意代码组织结构，因为这里边有声明和定义这种依赖关系在里边。
	B b;
	C c1;
	c1.callCAFB(3, b); // 3

	//总结：friend
	//优点： 允许在特定情况下某些非成员函数访问类的private, protected成员，从而提出友元这么一个概念；
	//使访问private, protected成员更灵活

	//缺点：这也就破坏了类的封装性，降低了类的可靠性和可维护性。

	system("pause");
	return 0;
}