C++类中的友元

声明关键字

template<class T>
friend T T_Name//这里的T表示声明的类型，T_Name表示类型名称

友元声明的作用

在一个类中，如果某个成员被private修饰而封装起来，对于外部的函数是无法访问到该成员信息的 但如果对外部访问函数进行友元修饰，函数就可以对类中的封装成员进行访问

#include<iostream>

class Building {
	friend void visit(Building* building);//友元的声明必须包含函数的签名，不能只包含函数名
private:
	std::string m_Sroom;
	std::string m_Broom;
public:
	Building() {
		m_Broom = "卧室";
		m_Sroom = "客厅";
	}
};

void visit(Building* building) {//这里如果未声明visit为友元函数，对于Building函数中的私有成员是无法进行访问的
	std::cout << building->m_Sroom << std::endl;
	std::cout << building->m_Broom << std::endl;
}

void test01() {
	Building* b = new Building;
	visit(b);
}
int main(void) {
	test01();
	return 0;
}

友元的不同类型

类类型的友元

#include<iostream>
class Add;

class members {
	friend void Add::add(members* m);
private:
	int a = 10;
	int b = 20;
};

class Add {
public:
	void add(members* m) {
		std::cout << m->a + m->b << std::endl;
	}
};

void test01() {
	Add a;
	auto m = new members;
	a.add(m);
}
int main(void) {
	test01();
	return 0;
}

其他类中的成员函数作友元

成员函数声明友元时，要注意声明的顺序，在声明其它类的成员函数时，需要保证友元声明前该类已经完成定义，因为类只有在完成定义之后才能访问其内部成员，编译器先执行声明操作，随后再执行函数定义，如果友元声明时类未完成定义，那么友元声明就不会执行。

#include<iostream>
class Son;

class Father {
public:
	int add(Son s);
};

class Son {
	friend int Father::add(Son s);
private:
	const int a = 10;
	const int b = 20;
};

int Father::add(Son s) {
	return s.a + s.b;
}

void test01() {
	Father f;
	Son s;
	int ans = f.add(s);
	std::cout << ans << std::endl;
}
int main(void) {
	test01();
	return 0;
}

注意声明其它类的成员函数的友元时声明的顺序，应当保证友元声明的类的作用域前声明的成员函数所属的类有完整定义，如果不存在完整定义，则友元声明会失效。