类和对象运用

构造函数的深入应用

初始化列表

以一个冒号开始，接着是一个以逗号分开的数据成员列表，每个“成员变量”后面跟一个放在括号中的初始值或表达式。

class date{
public:
	date(int year, int month, int day)
	 :_year(year),
	  _month(month),
	   _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

每个成员变量在初始化列表中只能出现一次。（因为初始化只能进行一次）
类中包含以下成员则必须在初始化列表位置进行初始化：

• 引用成员变量
• const成员变量
• 自定义类型成员

尽量使用初始化列表进行初始化。因为无论是否使用初始化列表对于自定义类型成员变量一定会先使用初始化列表进行初始化。
成员变量在类中生命次序就是其在初始化列表中的初始化顺序，预期在初始化列表中的先后次序无关。

class A{//输出 1-1
public:
	A(int a)
		:_a1(a)
		, _a2(a)
	{}
	void print(){
		cout << _a1 << "-" << _a2 << endl;
	}
private:
	int _a1;
	int _a2;
};

class B{
public:
	B(int a, int ret)
		:_null(a)
		, _ret(ret)
		, _n(10)
	{}
private:
	A _null;			//没有默认构造函数
	int &_ret;		//引用类型
	const int _n;	//const类型
};

int main(){
	A aa(1);
	aa.print();
}

explicit关键字

构造函数不仅可以构造和初始化对象，对单个参数的构造函数还有类型转换的作用。

static成员

声明为static的类成员被称为类的静态成员。用static修饰的成员函数称为静态成员函数。

静态成员函数一定要在类外初始化。

特性

1. 静态成员为所有类对象共享，不属于某个具体的实例。
2. 静态成员变量必选在类外定义，定义时不添加static关键字。
3. 类静态成员即可用类名：：静态成员或对象.静态成员来访问。
4. 静态成员函数没有隐藏的this指针，不能访问非静态成员。
5. 静态成员和类的普通成员一样，也有public，private，protected三种访问级别，也可以具有返回值。
6. 普通成员函数可以调用static函数。
7. 只能在该cpp所在的编译模块中使用static类型的全局变量。

友元

友元分为友元类和友元函数
友元提供了一种新的破除封装的方式。但友元会增加耦合度破坏了封装，不宜多用。

友元函数

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

准确来说友元函数可以访问类的所有成员

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin, Date& d);
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;

	return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;

	return _cin;
}
int main()
{
	Date d;
	cin >> d;
	cout << d << endl;
	return 0;
}

注意：

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

友元类

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

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

在time类中声明date类为其友元类，那么可以在date中直接访问time类的私有成员变量，但不能在time类中访问date类的私有成员变量。

• 友元关系不能传递

不存在朋友的朋友就是朋友这种情况

class Date; // 前置声明
class Time
{
	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour, int minute, int second)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}

private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t.second = second;
	}

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

内部类

一个类定义在另一个类内部。

此时的内部类为独立的类，不属于外部类，更不能通过外部类的对象去调用内部类。
内部类是外部类的友元类。

特性：

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

class A
{
private:
	 static int k;
	 int h;
public:
 	class B
	 {
	 public:
 		void foo(const A& a)
		 {
			 cout << k << endl;//OK
			 cout << a.h << endl;//OK
		 }
	 };
};