C语言第五天：构造函数初始化，友元，static，内部类

C语言从开始到放弃第五天：

1.构造函数初始化

构造函数体赋值

在构造对象时，编译器会通过构造函数，给成员对象赋上初始值。

Date(int year, int month int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

但是构造函数体中的语句仅仅能被称为赋值，不能称为初始化。初始化可以多次赋值，但只能初始化一次

构造函数体初始化

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

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

注意点：

1.初始化只能初始一次
2.必须在初始化列表位置进行初始化的：

1.引用变量

1.const成员变量
3.类类型成员（该类没有默认构造函数）

class A
{
	//省略
}

class B
{
private:
	int& _ret;//引用变量
	const int _n; //const类型
	A a;//类类型成员（无默认构造函数）
}

3.尽量使用初始化列表初始化，因为自定义类型必须要用到初始化列表初始化。

4.成员变量在类中的声明顺序就是初始化列表的先后顺序

class A
{
private:
	int* _a;//先
	int _size;//后
}

不能用_size在初始化列表中定义_a。

新版本C++支持的初始化方式

非静态成员在声明时，可以直接初始化

class A
{
private:
	int a = 10;
	int* p = (int*)malloc(4);
	B b = 10;//自定义对象
}

explicit关键字

定义：

用explicit修饰函数，将会拒绝单参数构造函数的隐式类型转换。

注意：

1.explicit关键字只需存在单参数构造函数前边。
2.优点：避免不合时宜的类型转换，缺点无。

参考：

explicit关键字详解

2.static成员

定义：

声明为static类的成员称为类的静态成员，用static修饰的成员变量，称为静态成员变量；用static修饰的成员函数，称为静态成员函数。

重点！

静态的成员变量一定要在类外定义。

注意：

1.静态成员为所有类对象所共享。
2.静态成员必须在类外定义，定义时不需要添加关键字static
3.类静态成员通过： 类名 ::静态成员 和 对象.静态成员 访问
4.静态成员其他属性和普通成员一样，可以用访问限定符，const等修饰。

3.友元

分类：友元函数和友元类
友元提供了突破封装的方法。但是友元提高了耦合性，破坏了封装。

友元函数

作用：可以直接访问类的私有对象，定义在类外的普通函数，需要在类的前面声明，在函数前加上friend。

class A
{
public:
	friend  int Add(int a, int b)
	{
		 a = a + b;
		 b = a - b;
		 a = a - b;
	}
private:
	int _a;
	int _b;
};
int Add(int a, int b)//不需要加::

注意：
1.友元函数可访问类的私有成员，但不是类的函数。
2.不能用const修饰
3.不受类的访问符限定，在类中的任何地方创建都可以
4.一个函数可以是多个类的友元函数
参考：
友元函数的理解和使用

友元类

友元类

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)
		, _t(0,0,0)
		{}
	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.友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类的成员
2.友元函数是单向的，不具有交换性
3.友元关系不可传递
4.A在B的类中声明为友元类，B就是弟弟，只能被调用。

4.内部类

概念：

如果一个类定义在一个类的内部，这个内部的类就叫做内部类。他不属于外部类，外部类对内部类并没有优越的访问权限。

注意

1.内部类可以定义在外部类的任意访问限定符之下
2.内部类可以可以直接访问外部类的成员
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，直接调用外部函数的私有成员
		}
	};
};

	int A::k = 1;

int main()
{
	A::B b;//调用内部类
	b.foo(A());//调用内部类的函数
	return 0;
}

5.理解封装

C++通过类，将一个对象的属性与行为结合在一起，使其更符合人们对于一件事物的认知，将属于该对象的所有东西打包在一起；通过访问限定符选择性的将其部分功能开放出来与其他对象进行交互，而对于对象内部的一些实现细节，外部用户不需要知道，知道了有些情况下也没用，反而增加了使用或者维护的难度，让整个事情复杂化。（以后自己总结）

例子：博物馆
有些东西是让你看的，有些东西是不让你动的，能动的东西是通过活动或者临时展览才可以触碰的。