构造函数

构造函数：在类中有一种特殊的成员函数，他的名字和类名相同，这个特殊的成员函数会被系统自动调用，这个成员函数叫做构造函数。因为构造函数会被系统自动调用，所以我们可以理解成构造函数的目的就是初始化类对象的数据成员。

1. 构造函数没有返回值。构造函数的特殊之处。
2. 不可以手动调用构造函数，否则编译出错。
3. 正常情况下，构造函数应该被声明为public。因为我们创建一个对象时，系统自动调用构造函数，这说明构造函数是public被系统调用。因为类缺省的成员是私有成员，构造函数需要加public，否则就无法创建该类的对象。
4. 构造函数中，如果有多个参数，则我们创建对象的时候，也要带上这些参数。

Time.h

#ifndef __MYTIME__
#define __MYTIME__
class Time {
private:
	int Millm;
private:
	void intMillTime(int mil);
public:
	int hour;
	int minute;
	int second;
	//成员函数
	void initTime(int h, int m, int s);
public:
	Time(int h, int m, int s);
};

#endif // !__MYTIME__

Time.cpp

void Time::initTime(int h, int m, int s) {
	hour = h;//注意到成员函数中，可以直接使用成员变量名。
			 //哪个对象调用的该成员函数，就是哪个对象的成员变量。函数知道哪个对象调用的自己
	minute = m;
	second = s;
	intMillTime(0);
}

void Time::intMillTime(int mil) {
	Millm = mil;
}

//构造函数的实现
Time::Time(int h, int m, int s) {
	hour = h;
	minute = m;
	second = s;
	intMillTime(0);
	cout << "调用了构造函数" << endl;
}

调用者

	#include "Time.h"
	Time myTime = Time(11, 12, 5);//创建了一个类对象
	Time myTime2(13, 15, 17);
	Time myTime3 = Time{ 12,13,52 };
	Time mytime4{ 12,13,25 };
	Time mytime5 = { 12,1,52 };

多个构造函数

一个类中可以有多个构造函数，多个构造函数可以为类对象的创建，提供多种初始化的方法。但是多个构造函数之间需要有些不同的地方，比如参数数量，参数类型上。

Time.h

#ifndef __MYTIME__
#define __MYTIME__
class Time {
private:
	int Millm;
private:
	void intMillTime(int mil);
public:
	int hour;
	int minute;
	int second;
	//成员函数
	void initTime(int h, int m, int s);
public:
	Time(int h, int m, int s);
	Time();
};

#endif // !__MYTIME__

使用者cpp

	Time myTime2(13, 15, 17);//调用相对应的构造函数
//调用无参构造函数
	Time myTime10 = Time();//创建了一个类对象,调用无参构造函数
	//Time myTime12(); 不能这么写
	Time myTime12;
	Time myTime13 = Time{};
	Time mytime14{ };
	Time mytime15 = { };

对象拷贝

	Time myTime20;//调用无参构造函数；

	//如下四个对象，没有调用无参构造函数，他们调用的是拷贝构造函数。
	Time myTime22 = myTime20;//对象拷贝进行初始化。用myTime20进行对象拷贝
	Time myTime23(myTime20);
	Time myTime24{ myTime20 };
	Time myTime25 = { myTime20 };

函数默认参数

1. 默认值只能放在函数声明（定义的时候）中。除非该函数没有函数声明。
2. 在具有多个参数的函数中，默认值必须出现在不带默认值参数的右边，只有一个参数有默认值，后面的参数必须有默认值。普通婆函数也可以有默认值。
3. 主意调用的时候可能引起多个函数匹配。

	Time myTime = Time(11, 12, 5);//如果同在存在狗仔函数Time(int h, int m, int s = 12);
								  //Time(int h, int m);会出现两个函数匹配，
	Time myTime2(13, 15, 17);
	Time myTime3 = Time{ 12,13,52 };
	Time mytime4{ 12,13,25 };
	Time mytime5 = { 12,1,52 };

隐式转换和explicit

编译系统会在私下干很多处理工作。

头文件

#ifndef __MYTIME__
#define __MYTIME__
class Time {
private:
	int Millm;
private:
	void intMillTime(int mil);
public:
	int hour;
	int minute;
	int second;
	//成员函数
	void initTime(int h, int m, int s);
public:
	Time(int h, int m, int s = 12);
	//Time(int h, int m);会出现多个函数匹配问题
	Time(int h);//不参数
	Time();//不参数
};

#endif // !__MYTIME__

调用文件

	void fun(Time myTime) {
	
	}
	
	Time myTime40 = 14;//如果没有带一个参数的构造函数，系统报错，语法错误，如果有，则调用带一个参数的构造函数。
	Time myTime40 = (12,13,14);//如果没有带一个参数的构造函数，系统报错，语法错误（即便有相符的三个参数的构造函数）。如果有，则调用带一个参数的构造函数。
	//让人很不可思议
	//编译系统把数字转换成Time类对象。
	fun(10);//应该传入Time类对象，整数发生了转换，被转换成了临时的Time对象，调用了带一个参数的构造函数。
	Time myTime100 = { 16 };
	Time myTime101 = (16, 51,13);//写法含糊不清，存在隐式转换问题
	Time myTime102 = 16;//写法含糊不清，存在临时变量的隐式转换
	fun(16);//写法含糊不清，存在临时变量的隐式转换

让人很不可思议的写法，强制系统，明确要求构造函数不能隐式转换？可以，如果构造函数声明成带有explicit，则这个构造函数只能用于初始化和显示类型转换。

改造构造函数：

Time(int h, int m, int s = 12);
Time(int h);//不参数

改造后类文件：

#ifndef __MYTIME__
#define __MYTIME__
class Time {
private:
	int Millm;
private:
	void intMillTime(int mil);
public:
	int hour;
	int minute;
	int second;
	//成员函数
	void initTime(int h, int m, int s);
public:
	explicit Time(int h, int m, int s = 12);
	//Time(int h, int m);会出现多个函数匹配问题
	explicit Time(int h);//不参数
	Time();//不参数
};

#endif // !__MYTIME__

调用者

	Time myTime = (11, 12, 5);//报错
	Time myTime2(13, 15, 17);//直接生成对象
	Time myTime3 = Time{ 12,13,52 };//直接生成对象
	Time mytime4{ 12,13,25 };//直接生成对象
	Time mytime5 = { 12,1,52 };//！！报错,赋值列表初始化不能使用标志为显示的构造函数
	//带三个参数的构造函数用explicit,则报错。这个初始化存在隐式转换。
	
	Time myTime100 = { 16 };//报错，赋值列表初始化
	Time myTime102 = (16);//报错
	Time myTime103(16);//直接生成对象
	Time myTime104{16};//直接生成对象
	Time myTime105 = (16);//报错
	fun((16));//报错
	
	//改造
	Time myTime100 = Time{ 16 };//调用带一个参数的构造函数。
	Time myTime102 = Time(16);//调用带一个参数的构造函数。
	Time myTime2 = Time(13, 15, 17);//调用带三个参数的构造函数。
	fun(Time(16));//调用带一个参数的构造函数。

对于单参数的构造函数，一般都声明成explicit ，用Time(…)或者Time{},

构造函数初始化列表

类对象不允许直接调用构造函数。

Time myTime.Time()//报错

构造函数初始化列表，改造三个参数的构造函数：

Time::Time(int h, int m, int s)
	:hour(h), minute(m), second(s), Millm(0)//构造函数初始化列表，在大括号前执行。有些东西必须用这个。叫初始化
											//专门用来初始化成员变量。
{
//hour = h;//叫赋值
}

提倡使用构造函数初始化列表

1. 专业，效率高。省去了下面的赋值语句。
2. 有些时候必须使用
3. 如果不使用构造函数初始化列表，相当于自动执行，系统给随机初始。
4. 类中谁先定义，先给谁初始化。不要用成员变量值给另一个成员变量赋值。

Time::Time(int h, int m, int s)
	:hour(h), minute(m), second(s), Millm(0)//类中先定义hour，就先给hour赋值。
{
//hour = h;//叫赋值
}