构造函数与析构函数浅析

提示：在阅读本篇文章之前，建议先了解默认参数与函数重载

前言构造函数默认构造函数析构函数默认析构函数拷贝构造函数默认拷贝构造函数

根据调查，有不少的程序错误是由于没有正确的初始化和清除造成的，这是因为程序员们容易遗忘掉初始化和清除的工作。而C++充分地考虑到了这个问题并给予了解决，引入了构造函数和析构函数。

构造函数是特殊的成员函数，它的作用是完成对对象成员变量的初始化工作。构造函数可分为普通构造函数（可简称为构造函数）和拷贝构造函数

【构造函数】
主要特点如下：

构造函数的函数名与类名相同。构造函数无返回值。对象实例化时自动调用构造函数构造函数可以重载。

class Data
{
public:
	//构造函数，完成初始化工作
	//函数名与类名相同
	//无返回值
	Data() 
	{
		_year = 2022;
		_month = 3;
		_day = 14;
	}
private:
	int _year;
	int _month;
	int _day;
};

对象实例化时，会自动调用构造函数

class Date
{
public:
	//构造函数，完成初始化工作
	//函数名与类名相同
	Date() 
	{
		_year = 2022;
		_month = 3;
		_day = 14;
		cout << "Date" << endl; //验证对象实例化时是否自动调用该函数
	}

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

int main(void)
{
    Date d1;
	return 0;
}

运行结果及监视窗口：

由此可见，在对象实例化的时候会自动调用构造函数来初始化成员变量。
另外，构造函数可以构成函数重载

class Date
{
public:
	Date()
	{
		_year = 2022;
		_month = 3;
		_day = 14;
	}
	//可重载,注意形参不是成员变量
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main(void)
{
	Date d1;
	Date d2(2022, 3, 15);
	return 0;
}

编译器会自动调用合适的构造函数，如果没有合适的构造函数，编译器就会报错。
结合我们之前学习的默认参数和函数重载，我们可以根据需求来设计参数列表。

	//可以根据需求来自己设计参数列表
	Date(int year = 2022, int month = 3, int day = 14)
	{
		_year = year;
		_month = month;
		_day = day;
	}

如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的构造函数，这个构造函数是隐式的，一旦用户显式定义构造函数，编译器将不再生成。

来大致了解一下C++里的类型

C++里把类型分成了内置类型和自定义类型。
内置类型指：基本数据类型 char / int / float / double / 指针 / 内置类型数组等
自定义类型：struct / class定义的类型

编译器默认生成无参的构造函数，对内置类型是不做处理的，仅仅对自定义类型做处理。

//测试编译器默认生成的构造函数
class A
{
public:
	//构造函数
	A()
	{
		_a = 13;
	}
private:
	int _a;
};
class B
{
private:
	int _b; //内置类型
	A _c; //自定义类型
};

int main(void)
{
	B test;
	return 0;
}

监视窗口：

对于自定义类型，编译器会去调用这个类的默认构造函数。

这里所指的默认构造函数：
1.我们不写编译器默认生成的构造函数
2.我们自己定义的无参的构造函数
3.我们自己定义的全缺省的构造函数

虽然支持函数重载，但是一个类里只能有一个默认构造函数，因为编译器调用的时候会存在歧义。

析构函数与构造函数的功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象的资源清理工作。

【析构函数】
主要特点如下：

析构函数的函数名为“~类名”。析构函数无返回值、无参数。对象生命周期结束时自动调用析构函数

//析构函数
class SeqList
{
public:
	//初始化
	SeqList(int capacity = 4)
	{
		_arr = (int*)malloc(sizeof(int) * capacity);
		//防止开辟空间失败
		assert(_arr);

		_size = 0;
		_capacity = capacity;
	}
	//析构函数
	~SeqList()
	{
		if (_arr)
		{
			free(_arr);
			_arr = NULL;
			_size = _capacity = 0;
		}
	}
private:
	int* _arr;
	size_t _size; //数据个数
	size_t _capacity;//容量
};

当对象生命周期结束后，会自动调用析构函数。

如果类中没有显式定义析构函数，则C++编译器会自动生成一个析构函数，这个析构函数是隐式的，一旦用户显式定义构造函数，编译器将不再生成。

这个默认的析构函数其实和构造函数是类似的。如果我们没有定义析构函数，而编译器默认生成的析构函数是不会对内置类型进行处理的，仅对自定义类型进行处理。

拷贝构造函数使用一个同类型的对象去实例化新的对象。拷贝构造函数只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

【拷贝构造函数】
主要特点如下：

拷贝构造函数的函数名与类名相同。拷贝构造函数无返回值。拷贝构造函数是构造函数的一个重载形式参数是不能进行修改的只有一个参数且必须使用引用传参，使用传值传参会引发无限递归

//拷贝构造函数例子
class Test
{
public:
	Test(int a = 0, int b = 0)
	{
		_a = a;
		_b = b;
	}
	//拷贝构造函数，自动调用
	Test(const Test& T)
	{
		_a = T._a;
		_b = T._b;
	}
private:
	int _a;
	int _b;
};

int main(void)
{
	Test test1(12, 34);
	Test test2(test1); //拷贝构造，使用一个已经存在的对象创建并初始化一个新的对象。
	return 0;
}

要注意，拷贝构造函数不能使用传值传参。为什么呢？
首先我们应该知道，使用传值传参时，形参是实参的一份拷贝。

	//传值会引发无限递归
	Test(const Test T)
	{
		_a = T._a;
		_b = T._b;
	}

意味着这个时候对于实参test1 要拷贝一份给T对象，而这个过程又要调用一次拷贝构造函数，这样就造成了无限调用拷贝构造函数的情况，所以不能使用传值传参。

如果类中没有显式定义拷贝构造函数，则C++编译器会自动生成一个拷贝构造函数，这个拷贝构造函数是隐式的，一旦用户显式定义拷贝构造函数，编译器将不再生成。

默认生成的拷贝构造函数：
1.内置类型完成按字节序的拷贝，也就是所谓的浅拷贝
2.自定义类型会去调用它自己的拷贝构造函数。

//编译器默认生成的拷贝构造函数
//对内置类型实现浅拷贝，也就是按字节序进行拷贝
//对于自定义类型会去调用它自己的拷贝构造函数
class Test
{
public:
	Test(int a = 0, int b = 0)
	{
		_a = a;
		_b = b;
	}
private:
	int _a;
	int _b;
};

int main(void)
{
	Test test1(12, 34);
	Test test2(test1); //拷贝构造，使用一个已经存在的对象创建并初始化一个新的对象。
	return 0;
}