类与对象--友元

生活总会让我们遍体鳞伤，但那些受过伤的地方一定会成为我们最强壮的地方

友元

生活中你的家有客厅(Public)，有你的卧室(Private)客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去但是呢，你也可以允许你的好闺蜜好基友进去。
在程序里，有些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术
友元的目的就是让一个函数或者类 访问另一个类中私有成员
友元的关键字为 friend
友元的三种实现

• 全局函数做友元
• 类做友元
• 成员函数做友元

#include<iostream>
#include<string>
using namespace std;
class building;
class goodfriend {
private:
	building* _build;
public:
	goodfriend();
	void access();
	void visit1();
	void visit2();
};
class building {
	friend class goodfriend;//告诉编译器，goodfriend类1是本类的好朋友，可以访问本类中的私有成员
	friend void visit(building* build);// friend 修饰全局函数
	friend void goodfriend:: visit1();//成员函数做友元可以访问本类中的私有成员
private:
	string _bedroom;
public:
	string _Sitingroom;
	building();
};
//类外实现成员函数
building::building()
{
	this->_bedroom = "卧室";
	this->_Sitingroom = "客厅";
}
goodfriend::goodfriend()
{
	_build = new building;
}
void goodfriend::access()
{
	cout << "类做有元" << endl;
	cout << "好朋友正在访问：" << this->_build->_Sitingroom << endl;
	cout << "好朋友正在访问：" << this->_build->_bedroom<< endl;
}
void goodfriend::visit1()
{
	cout << "成员函数友元" << endl;
	cout << "好朋友正在访问：" << this->_build->_Sitingroom << endl;
	cout << "好朋友正在访问：" << this->_build->_bedroom << endl;
}
void goodfriend::visit2()
{
	cout << "好朋友正在访问：" << this->_build->_Sitingroom << endl;
	//cout << "好朋友正在访问：" << this->_build->_bedroom << endl;
}

//全局函数
void visit(building* build)
{
	cout << "全局函数做有元" << endl;
	cout << "好朋友正在访问：" << build->_Sitingroom << endl;
	cout << "好朋友正在访问：" << build->_bedroom << endl;

}
void test01()
{
	//全局函数做友元
	building p1;
	visit(&p1);
	//类做友元
    //1. 友元关系是单向的，不具有交换性。
    //2. 友元关系不能传递
    //3. 友元关系不能继承
	goodfriend p2;
	p2.access();
	//成员函数做有元
	goodfriend p3;
	p3.visit1();
	p3.visit2();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

运行结果：

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以
友元不宜多用。

内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，
它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越
的访问权限。
注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访
问外部类中的所有成员。但是外部类不是内部类的友元。
特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系。

#include<iostream>
using namespace std;
class person {
private:
	int _age;
	static int id;
public:
	class son {  //son 天生就是 person 的友元
		// son 就是普通类，只是受person的类域和访问限定符的限制
	private:
		int _name;
	public:
		void foo(const person& p1)
		{
			cout << id << endl;
			cout << p1._age << endl;
		}

	};	
};
int person::id = 150;
void test01()
{
	cout << "sizeof person = " << sizeof(person) << endl;
	person::son s;
	s.foo(person());//
}

int main()
{
	test01();
	system("pause");
	return 0;
}

好啦，关于类与对象–友元就先学到这，如果对您有所帮助，欢迎一键三连，您的支持是我创作的最大动力