深入篇【C++】类与对象：友元函数与友元类

①.提出问题：重载operator<<

如果我们尝试去重载运算符operator<<,你将会发现没有办法将operator<<重载成成员函数。
为什么呢？我们需要了解一下流插入cout和流提取cin的一些知识，我们知道流插入cout对于内置类型可以直接打印出来，那么对于自定义类型是否可以打印呢？
答案是可以的，为什么呢？
1.cout<<可以直接支持内置类型，是因为库里实现了对于内置类型的运算符重载。
2.cout<<可以直接支持自定义识别类型，是因为库里也实现了对于自定义类型的运算符重载，而这两个运算符重载函数又构成函数重载。
但流插入cout<<不能写成成员函数。
因为cout的输出流对象和隐藏的this在抢占第一个形参的位置。this指针默认是第一个参数也就是左操作数，但实际上使用cout<<时，第一个参数应该是流插入cout，这样才正常，而成员函数第一个参数必须是this指针，所以operator<<无法写成成员函数，只能写成全局函数。

//尝试重载<<运算符,让它可以输出对象的数据
class  Data
{
public:
	
	Data(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{
	}
	//按照成员函数的规定，第一参数必须是this指针，第二参数才可以是cout
	//但这样写不符合cout<<写法 cout应该在左边，cout右边是要输出的数据
	ostream& operator<<(ostream& _cout)
	{
		_cout << _year << "-" << _month << "-" << _day << endl;
		return _cout;
	}
	//但如果要写成ostream& operator<<(ostream&_cout,&d),这样又会出现一个问题，第一参数必须是隐藏的this指针，也就是必须是调用该函数的对象的指针，那调用函数时就变成这样了 d1<<cout,d1.operator<<(&d1,ostream&_cout)
	
	//矛盾的是正常写法是cout<<d1.但在类里面无法实现这样的形式，所以必须到类外面写
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout, const Data& d)// cout<<d1
{
	_cout << d._year << "-" << d._month << "-" << d._day << endl;//问题无法访问类私有成员
	return _cout;
}
int main()
{
	Data d1;
	//d1 << cout;//虽然可以打印出来，但不符合常规调用。
	cout << d1;//正常应该是这样使用
}

但写到类外面又会存在问题：在类外面无法访问类的私有成员。
这个问题该如何解决呢？
这时候就需要友元来解决。

②.解决问题：友元

友元提供了一种突破封装的方式，有时候提供了便利，可以在类外面访问类的私有成员。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元分为：友元函数和友元类。

Ⅰ.友元函数

友元函数可以直接分为类的私有成员，它是定义在类外的普通函数，不属于任何类，但是要在类里面声明，这样才可以成为友元函数，声明时需要加friend关键字

class  Data
{
public:
//将函数变成友元函数后就可以访问类的私有成员了。
//要注意在类外定义在类里声明，声明时要使用friend关键字
	friend ostream& operator<<(ostream& _cout, const Data& d);
	Data(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{

	}
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout, const Data& d)// cout<<d1
{
	_cout << d._year << "-" << d._month << "-" << d._day << endl;//变成友元函数后，就可以通过d对象来访问对象中的私有数据。也就是类的私有成员。
	return _cout;
}
int main()
{
	Data d1;
	cout << d1;
}

注意：要支持插入流可以连续打印，所以要使该重载函数的返回值仍然为cout类型即ostream，这样就可以支持连续打印了。

【特点】

1.友元函数可以直接访问类的私有和保护成员，不是类的成员函数。
2.友元函数不能用const修饰
3.友元函数的声明可以在类的任意地方声明，不受访问限定符的限制。
4.一个函数可以是多个类的友元函数。
5.友元函数的调用和普通函数的调用原理相同。

Ⅱ.友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
友元类就是在A类中将B类声明为友元，那这个B类的任意成员函数都是A类的友元函数了，都可以访问这个A类的私有成员了。

class Time
{
	friend class Data;//声明日期类是时间类的友元类。
	//则在日期类中，所有的成员函数都可以随意访问时间类的成员变量。
public:
	Time(int year = 2, int month = 2, int day = 2)
		:_year(year)
		, _month(month)
		, _day(day)
	{

	}
	
private:
	int _year;
	int _month;
	int _day;
};

class  Data
{
public:

	Data(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{

	}
	//因为Data类是Time类的友元类，所以Data的所以成员函数都可以访问Time类的成员变量。
	void ChangeTime(int year = 2023, int month = 5, int day = 20)
	{
		_t._year = year;
		_t._month = month;
		_t._day = day;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};
int main()
{
	Data d1;
	d1.ChangeTime();
}

【特点】

1.友元关系是单向的，不具有交换性。
比如上面的Date类是Time类的友元类，Date在Time里被声明为友元后，那么在Data类中就可以直接访问Time类的成员变量，但想在Time类中去访问Data类的成员变量是不可以的。
2.友元关系不能传递。
比如A是B的友元类，B是C的友元类，不可以说A是C的友元类喔。
3.友元关系是不可以继承的。

③.总结问题

对于一些重载函数比如operator<<和operator>>因为成员函数的特性无法写进类里，不得不写成全局函数，而遇到的的统一问题：无法访问类的私有成员。
这时就必须得使用我们的友元函数来解决这样的问题：当不得不访问一个封装类的数据时，可以使用友元来处理。
而使用友元时需要注意友元的使用技巧。
1.在类外定义，类里声明，使用关键字friend。
2.友元无法使用const修饰。
3.友元声明不受访问限定符限制。
4.尽量少使用友元，因为友元会破坏封装，增加耦合度。