友元 + 内部类 + 匿名对象

友元

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

友元分为两种，分别是：

1. 函数做友元
2. 类做友元

函数做友元

问题：现在尝试重载operator<<函数，输出日期类对象

class Date
{
	Date(int year, int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{}

	//这样写是没有办法将operator<<重载成成员函数的
	//因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置
	//this指针默认的是第一个参数，也就是左操作数。
	//但是实际使用中cout需要是第一个参数对象，才能正常使用
	ostream& operator<<(ostream& _out)
	{
		_out << _year << "-" << _month << "-" << _day << endl;
		return _out;
	}
private:
	int _year;
	int _month;
	int _day;
};

面临了一个问题：我们既想要能初始化，那么就要ostream作为第一个参数，又想要能够访问私有成员，那么就要作为成员函数，成员函数又有this指针，和第一个矛盾。

友元函数能够解决这样的问题。

友元函数能够直接访问类内的私有成员，它是定义在类外部的普通函数，不属于任何类，但是需要在类的内部声明，声明时需要加friend关键字。

class Date
{
	friend ostream& operator<<(ostream& _out, const Date& d);
public:
	Date(int year = 1990, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

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

ostream& operator<<(ostream& _out, const Date& d)
{
	_out << d._year << "-" << d._month << "-" << d._day << endl;

	return _out;
}

int main()
{
	Date d1;
	cout << d1;
	return 0;
}

注意：因为ostream& operator<<(ostream& _out, const Date& d);定义在外面，所以就是普通函数，普通函数想要访问类内的成员，就要指定，所以需要第二个参数写成Date& d，至于为什么这里写成了const Date& d，是因为我们不想修改d的值，可以写成const。一个原则：如果可以写成const，最好都写成const。

这涉及权限放大和缩小到的问题。

附赠:重载operator>> 和 operator<<

class Date
{
	friend ostream& operator<<(ostream& _out, const Date& d);
	friend istream& operator>>(istream& _in, Date& d);
public:
	Date(int year = 1990, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

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

ostream& operator<<(ostream& _out, const Date& d)
{
	_out << d._year << "-" << d._month << "-" << d._day << endl;

	return _out;
}

istream& operator>>(istream& _in, Date& d)
{
	_in >> d._year >> d._month >> d._day;
	return _in;
}
int main()
{
	Date d1;
	cin >> d1;
	cout << d1;
	return 0;
}

总结

• 友元函数可访问类的私有和保护成员，但不是类的成员函数
• 友元函数不能用const修饰
• 友元函数可以在类定义的任何地方声明，不受类访问限定符的限制
• 一个函数可以是多个类的友元
• 友元函数的调用与普通函数的调用原理相同

类做友元

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类的非公有成员。

• 友元关系是单向的，不具有交换性

  理解：假设这里有Time 和 Date 两个类，其中，Time把Date设为友元类，这就意味着，Time认为Date是他的朋友，让他访问家里的成员。但是Date却不认为Time是他的朋友，所以Date不允许Time访问他的成员。

• 友元函数不能传递
  理解：Time表示，我认为Date是我的好友，Date认为A是他的好友，那么Time不能认为A也是自己的好友。

• 友元关系不能继承
  理解：Time表示，我认为Date是我的好友，B是Date的儿子，那么Time不能认为A也是自己的好友。

class Time
{
	friend class Date;
public:
	Time(int hour = 1, int minute = 0, int second = 0)
		:_hour(hour)
		,_minute(minute)
		,_second(second)
	{}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
public:
	Date(int year = 1990, int month = 1, int day = 1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}

	void GetTime(int hour, int minute, int second)
	{
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

内部类

如果一个类定义在另一个类的内部，那么这个类就叫做内部类。
内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

• 内部类的外部类天生的友元
• 内部类访问外部类的static成员不需要外部类的对象/类名

class A
{
public:
	class B
	{
	public:
		void fun(const A& a)
		{
			cout << _k << endl;   // 内部类访问外部类的static成员不需要外部类的对象/类名
			cout << a._a << endl;
		}
	};
private:
	int _a;
	static int _k;
};

匿名对象

什么是匿名对象：就是没有名字的对象……

匿名对象产生的三种情况

• 以值的方式给函数传参
  fun()
  ----生成了一个匿名对象，执行完fun( )代码后，此匿名对象就此消失。这就是匿名对象的生命周期。

  A a = fun()
  ----生成了一个匿名对象，然后将此匿名对象变为了a对象，其生命周期就变成了a对象的生命周期。

• 类型转换

• 函数需要返回一个对象时

匿名对象具有常性（非常重要）
因为匿名对象具有常性，所以下面这种写法是错误的。

为什么是错误的？
因为引用变量a绑定一个匿名对象的时候，匿名对象Date()作为一个临时变量具有常性，所以要求引用变量a必须用const修饰。

所以下面这种写法才是正确的。

使用匿名对象，减少开销：
当同一步骤中的构造 + 拷贝构造，系统会优化为一次构造函数

class Date
{
public:
	Date(int year = 1990, int month = 1, int day = 1)
	{
		cout << "构造函数" << endl;
	}

	Date(const Date& d)
	{
		cout << "拷贝构造函数" << endl;
	}

	~Date()
	{}
private:
	int _year;
	int _month;
	int _day;
};

Date fun()
{
	Date d1;
	return d1;
}

void fun1(Date d)
{}

int main()
{
	Date d = Date(1, 1, 1);  //构造 + 拷贝构造  --> 优化为构造函数

	cout << "============" << endl;

	Date d1;
	fun1(d1);           //不会优化

	cout << "=============" << endl;

	fun1(1);		//构造 + 拷贝构造  --> 优化为构造函数
	Date d2 = 1;	//构造 + 拷贝构造  --> 优化为构造函数
	return 0;
}

观察运行结果：

匿名对象的生命周期

Date d (1, 1, 1);  //有名对象   ---   生命周期在当前函数局部域
Date(1,1,1)       // 匿名对象   ---   生命周期在当前行
const Date& d = Date(1, 1, 1) // const引用延长匿名对象的生命周期，生命周期在当前函数局部域