一. 类的六个默认成员函数

对于任意一个C++类，如果用户不定义任何成员函数，那么编译器就会自动生成6个默认成员函数。当然，这6个成员函数也可以由用户自主定义，如果用户自主定义了，那么系统就不会自动生成。这6个默认成员函数包括：构造函数、析构函数、拷贝构造函数、赋值重载函数、对普通对象和const对象的取地址重载函数。

二. 构造函数

2.1 什么是构造函数

构造函数在定义类对象是由编译的自动调用，用于初始化类的成员变量。构造函数是一种十分特殊的成员函数，它没有返回值，它的函数名与类名相同。

任何一个类都不能没有默认构造函数，否则这个类就是非法的，在用这个类初始化对象时编译器会报错。默认构造函数，就是不需要参数就可以调用的构造函数，默认构造函数有三种可能的形式：

无参数
全缺省参数
由编译器自动生成的构造函数

演示代码2.1定义了一个日期类，并定义了一个全缺省的构造函数，这里由于用户自定义了构造函数，所有编译器不会生成默认构造函数。此外，还应当明确，构造函数是支持重载的，Date(int year = 1, int month = 1, int day = 1)可以被拆分为一个无参的构造函数Date()和一个不存在确实参数的构造函数Date(int year, int month, int day)。

演示代码2.1：

class Date  //日期类
{
public:
	Date(int year = 1, 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;
};

int main()
{
	//定义类对象，调用默认构造函数
	Date d1;  //Date(1, 1, 1)
	Date d2(2023, 2, 26);  //Date(2023, 2, 26)

	d1.Print();  //1-1-1
	d2.Print();  //2023-2-26

	return 0;
}

2.2 编译器自动生成的默认构造函数

当用户不自定义默认构造函数时，编译器就会自动生成默认构造函数，编译的自动生成的构造函数进行的工作为：

对于内置类型成员变量，不进行初始化
对于自定义类型成员变量，调用自定义类型成员变量的默认构造函数

其中，内置类型指int、char、double、float、指针、内置类型数组等C/C++自带的数据类型，自定义类型指使用struct/class定义的类或结构体数据类型。

为了验证编译器自动生成的构造函数所完成的功能，在演示代码2.2中定义了一个Date类和一个Time类，在Date类中不自定义构造函数，在Time类中定义默认构造函数将Time中的成员变量全部初始化为1，Date类中包括3个内置类型成员变量和1个Time类类型的成员变量。对程序进行调试，可见定义好的Date类对象d1中的内置类型成员变量都是随机值，而d1中的类对象t的成员变量都变变为了1。这就证实了上面对编译的自动生成的构造函数进行的工作的讲述的正确性。

演示代码2.2：

class Time
{
public:
	Time(int hour = 1, int minute = 1, int second = 1)  //自定义默认构造函数
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}

private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	int _year;
	int _month;
	int _day;
	Time t;
};

int main()
{
	Date d1;  //定义类对象，调用编译器自动生成的默认构造函数
	return 0;
}

我们可以认为默认构造函数不对内置类型成员变量做任何处理是C++的一个缺陷。为了弥补这一缺陷， C++11允许在定义类是显示的声明内置类型成员变量的初值。如演示代码2.3所示，Date类中的三个成员变量都被赋默认初值1。

演示代码2.3：

class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year = 1;
	int _month = 1;
	int _day = 1;    //三个内置类型的成员变量的默认初值都为1（C++11）
};

int main()
{
	Date d;
	d.Print();  //1-1-1
	return 0;
}

2.3 构造函数的特性总结

构造函数是特殊的成员函数，函数名与类名相同，无返回值。
构造函数在对象实例化时由编译器自主调用，无需用户手动调用。
构造函数可以重载。
如果用户不显示定义构造函数，那么编译器就会生成默认的构造函数。

三. 析构函数

3.1 什么是析构函数

析构函数的功能与构造函数相反，在类对象生命周期结束时，由编译器自动调用，完成对类对象的资源清理工作，析构函数的函数名为：~类名。

析构函数可以由用户自身定义，也可以由编译器自主生成。当拥护显示的定义了析构函数时，编译器不自动生成析构函数，但当用户不显示的定义析构函数时，编译器会自动生成默认的析构函数。

析构函数没有参数、没有返回值。

演示代码3.1定义了一个简易的栈类Stack，其中定义了三个成员变量：int* _a -- 存储栈数据的数组、int _top -- 栈顶位置下标、int _capacity -- 栈容量，还定义了四个成员函数：Stack -- 栈初始化函数（构造函数）、Push -- 压栈函数、Print -- 栈中数据打印函数、~Stack -- 栈销毁函数（析构函数）。在~Stack函数中释放了动态开辟的内存。

在主函数中，我们创建了一个栈类对象S，程序的运行结果表明，构造函数和析构函数先后被调用。

演示代码3.1：

class Stack
{
public:
	Stack(int capacity = 3)  //构造函数，初始化栈，类实例化时自动调用
	{
		cout << "Stack()" << endl;

		_a = (int*)malloc(capacity * sizeof(int));  //为栈数组动态开辟内存空间
		if (nullptr == _a)
		{
			cout << "malloc fail" << endl;
			exit(-1);
		}

		_capacity = capacity;
		_top = 0;
	}

	void Push(int x)  //压栈函数，x为压入数据
	{
		if (_top == _capacity)  //检查栈是否已满
		{
			int* tmp = (int*)realloc(_a, (_capacity * 2) * sizeof(int));  //开辟新的内存空间
			if (tmp == nullptr)
			{
				cout << "realloc fail" << endl;
			}

			_a = tmp;
			_capacity *= 2;
		}

		_a[_top++] = x;
	}

	void Print()  //栈中数据打印函数
	{
		for (int i = 0; i < _top; ++i)
		{
			cout << _a[i] << " ";
		}
		cout << endl;
	}

	~Stack()  //析构函数，在对象生命周期结束时自动调用
	{
		cout << "~Stack()" << endl;

		free(_a);  //释放栈空间
		_a = nullptr;
		_top = _capacity = 0;
	}

private:
	int* _a;  //存储栈数据的数组
	int _top;  //栈顶下标
	int _capacity;  //栈容量
};

int main()
{
	Stack S;  //类实例化，调用默认构造函数

	S.Push(1);
	S.Push(2);
	S.Push(3);
	S.Push(4);
	S.Push(5);  //将1、2、3、4、5压入栈中
	S.Print();  //打印栈中数据

	return 0;  //对象生命周期结束，调用析构函数
}

3.2 编译器自动生成的析构函数

如果用户不显示定义析构函数，则编译器会生成默认的析构函数，编译器自动生成的析构函数所执行的操作与编译器自动生成的构造函数类似：

对于内置类型成员变量，不做任何处理。
对于自定义类型成员变量，去掉它的析构函数。

演示代码3.2定义了一个名为TwoStack的类，其中包含两个Stack类的自定义类型成员变量S1和S2，在主函数中对类进行实例化，创建对象ts，在ts创建和销毁时都调用Stack的默认构造函数和析构函数。

演示代码3.2：

class TwoStack
{
private:
	Stack S1;
	Stack S2;
};

int main()
{
	TwoStack st;  //类实例化，调用默认构造函数
	return 0;  //对象生命周期结束，调用析构函数
}

问题：什么时候可以使用编译器自动生成的析构函数，什么时候必须显示定义析构函数？

当类中的成员变量仅在栈区占用内存空间时，类对象的生命周期结束是成员变量所占用的空间自动被释放，不需要析构函数执行额外的操作，如日期类Date，就不需要自定义析构函数。
当类的成员变量执行堆区开辟的某一块空间时，如通过malloc动态开辟了内存空间，就需要显示的定义析构函数来进行资源清理，如Stack类就不能使用编译器自动生成的析构函数。