类与对象（2）—— 构造函数

构造函数

定义：构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

特性：
（1） 函数名与类名相同。
（2）无返回值。
（3）对象实例化时编译器自动调用对应的构造函数。
（4）构造函数可以重载。
（5）如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
（6）无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。
注意：
默认构造函数，有3种
a.我们不写，编译器默认生成的（编译器一般不处理变量，是一个随机值）
b.我们自己写的无参的
c.我们写的全缺省的构造函数
总结一下：不用传参就可以调用的函数

class Date
{
public:
	//可能我们会忘记调用初始化函数
	//C++为了解决这个问题，引入构造函数来初始化
	void Init(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;
	//}
	构造函数可以重载
	//Date()
	//{
	//	_year = 0;
	//	_month = 1;
	//	_day = 1;
	//}

	//一般情况，对象初始化惯例都分两种，默认值初始化，给定值初始化
	//如果合二为一，给一个全缺省的
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	void Print()
	{
		cout << _year << "_" << _month << "_" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

class Stack
{
public:
	void Init()
	{
		_a = nullptr;
		_size = _capacity = 0;
	}
	//构造函数
	Stack()
	{
		_a = nullptr;
		_size = _capacity = 0;
	}

	Stack(int capacity)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		_size = 0;
		_capacity = capacity;
	}

	void Push(int x)
	{
	
	}
private:
	int* _a;
	int _size;
	int _capacity;
};
int main()
{
	Date d1(2021,5,24);
	d1.Print();
	//未初始化 d1.Print();

	Date d2;
	d2.Print();  //调用不带参的构造函数

	//全缺省的初始化
	Date d3(2021);
	d3.Print();

	Stack st;
	st.Push(1);

	Stack st2(10);  //开辟空间
	st.Push(1);
	return 0;
}

（7）关于编译器生成的默认成员函数，很多童鞋会有疑惑：在我们不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是对象year/month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？
解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好类型：如int/char…，自定义类型就是我们使用class/struct/union自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数.

class A
{
public:
	A(int a = 0)
	{
		_a = a;
	}
	void Print()
	{
		cout << _a << endl;
	}
private:
	int _a;

};
class Date
{
public:
	//我们不写，编译器会生成一个构造函数，我们写了编译器就不会生成了，所以说构造函数叫做默认成员函数
	void Print()
	{
		cout << _year << "_" << _month << "_" << _day << endl;
		//cout << _aa.a <<endl;  //不能访问a
		_aa.Print();
	}
private:
	//以下是内置类型，语言原生定义的类型，如：int\double\char等
	
	int _year;
	int _month;
	int _day;


	//自定义类型，使用struct、class等定义的类型，编译器会去调用他们的默认构造函数初始化
	A _aa;
};