在很多时候，当写了初始化，动态开辟的，需要写销毁函数，写了销毁函数之后，但是却忘记了调用这些函数，忘记调用初始化函数还好，编译器会报错，但是如果是忘记调用销毁函数，那么编译器是不会报错，但是不能说这个程序就没错哦了，反而有很大的问题，存在内存泄漏的问题，如和解决这样问题？这也是本文重点。C++增加了类的6个默认成员函数，本文先分享构造函数和析构函数。
构造函数–主要完成初始化工作，
析构函数–主要完成清理工作

一、前言

在很多时候，当写了初始化，动态开辟的，需要写销毁函数，写了销毁函数之后，但是却忘记了调用这些函数，忘记调用初始化函数还好，编译器会报错，但是如果是忘记调用销毁函数，那么编译器是不会报错，但是不能说这个程序就没错哦了，反而有很大的问题，存在内存泄漏的问题，如和解决这样问题？这也是本文重点。C++增加了类的6个默认成员函数，本文先分享构造函数和析构函数。

构造函数–主要完成初始化工作
析构函数–主要完成清理工作

二、构造函数

构造函数是特殊的成员函数，虽然它的名字叫构造函数，但是它的主要任务不是开空间创建对象，而是初始化对象
特性：
1、函数名和类名相同。 如：类名Stack,那么构造函数的函数，名也为Stack
2、无返回值（也不需要void)。
3、对象实例化编译器自动调用对应的构造函数。对象在定义之后就会调用它的默认构造函数
4、构造函数可以重载。(构造函数虽然没有返回值，但是可以有参数)
5、如果类中没有显式定义构造函数，则c++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义，编译器不再默认生成。

以日期类带大家了解

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year=2022, int month=4, int day=24)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << '-' << _month << '-' << _day << endl;
	}

	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	d1.Print();
	return 0;
}

在对象定义之后并没有显式调用构造函数，但是在打印这个对象的时候却是有内容的，因为在对象定义时编译器自动调用它的默认构造函数，（默认构造函数是构造函数参数列表全缺省）


构造函数是没有返回值的，且它的函数名与类名相同，它还能有参数也可以没有参数
无参和参数列表全给缺省值这两个函数在同一个类中只能出现其中之一

构造函数支持重载

对重载构造函数的调用

当构造函数重载，一个构造函数无参数，一个构造函数参数列表全给缺省值，对象定义之后自动调用它的默认构造函数，编译器不知道调用谁，此时会发生调用歧义，所以得出，构造函数无参数和参数列表全给缺省值这两个在一个类中只能出现其中之一，一个出现另一个就不能出现。

构造函数参数列表全为缺省参数或者无参时，在对象定以之后会自动调用，那么如果构造函数参数列表不权威缺省参数或者不为缺省参数时，应当如何？

当构造函数参数列表不全是缺省值时

此时会显示d1这个对象并不存在默认构造函数，在定义之后不能自动调用它的构造函数了
那么在定义对象时就不能简简单单的定义了 而是对象+参数列表，此时编译器才会自动调用构造函数
但是就算构造函数参数列表全为缺省参数或者无参，也不能像这样

此时编译器并不知道这个对象是声明还是定义

Data d1;//当构造函数参数列表全是缺省值时，编译器在对象实例化时才会默认自动调用构造函数，不然的话就需要对其传参
对象+参数列表，此时就会自动调用构造函数

构造函数：要么是无参、要么是全缺省、要么是没有显式写编译器会自动生成默认构造函数（不传参就可以调用的函数就是默认构造函数）

构造函数替代了Init（初始化）,可以不用调用Init也对这个对象初始化了，这样也就解决了因没有调用初始化带来的错误，
构造函数是给对象初始化，在对象定义时自动调用

但是如果当类中没有定义构造函数时，应该如何处理？

编译器会自动生成构造函数，但是自动生成的构造函数，编译器并没用对类中的内置类型成员初始化
但是也有一些编译器会将其内置类型成员初始化为0，不过大多数是不会处理的

内置类型：（int/double/指针等等）
自定义类型:自己定义的/struct/class等等定义的类型

编译器自动生成构造函数也并不是什么都不做，当我们在类中，不显式写构造函数，编译器会默认生成构造函数，类中内置类型不做处理，自定义类型会调用它的默认构造函数

以日期类中字自定义一个栈对象来看

#include<iostream>
using namespace std;
class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			perror("malloc fail
");
			return;
		}

		_top = 0;
		_capacity = capacity;

		cout << "_top" << ' ' << "_capacity" << endl;
	}
	int _capacity;
	int* _a;
	int _top;
};


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

	int _year;
	int _month;
	int _day;

	Stack _st;
};

int main()
{
	Data d1;
	d1.Print();

	return 0;
}

可以发现，自动生成了默认构造函数，这里类的内置类型成员被处理为0了，其实大多数编译器是不会对类的内置类型成员进行处理

当类中没有构造函数时，编译器会默认自动生成构造函数 但是并不会对类的内置类型成员做处理（初始化）
当类中有自定义类型成员时，编译器会默认自动调用自定义类型它的构造函数，
同时有些编译器也会将类的内置类型成员初始化为0，但是这只是有些编译器，并不是全部

那么哪种类可以让编译器默认自动生成构造函数哪些不能？ 一般情况下，类只要有内置类型成员，理论上不能让编译器默认自动生成构造函数
一般情况下，如果类成员全是自定义类型成员，可以考虑让编译器默认自动生成构造函数（两个栈实现队列）

所以在c++11标准发布，也算是为其做了一些补丁
在类中内置类型成员在声明的时候给缺省值，此时编译器默认自动生成构造函数时
这些内置类型成员不再是随机值，而是这些缺省值

#include<iostream>
using namespace std;
class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			perror("malloc fail
");
			return;
		}

		_top = 0;
		_capacity = capacity;

		cout << "_top" << ' ' << "_capacity" << endl;
	}
	int _capacity;
	int* _a;
	int _top;
};


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

	//可以在声明时给其缺省值
	int _year = 1;
	int _month = 1;
	int _day = 1;

	Stack _st;
};

int main()
{
	Data d1;
	d1.Print();

	return 0;
}

类中没有定义构造函数，编译器会自动生成默认构造函数，再自动调用生成的构造函数，然后此时对类的内置类型成员给缺省值，此时就相当于是对类的内置类型成员处理

1. 类中没有显式定义构造函数，编译器会自动生成一个无参的默认构造函数
2. 内置类型成员不做处理（a 有些编译器会处理 b.c++11标准对其缝补，声明可以给缺省值初始化）
3. 自定义类型成员，会自动去调用它的构造函数

关于构造函数
总结：

1. 一般情况下，构造函数都需要我们自己显式写
2. 内置类型成员都有缺省值，且这些缺省值初始化符合自己要求，不用显式写构造函数
3. 类中成员全是自定义类型，且这些类型都定义默认构造函数，不用显式写构造函数

三、析构函数

析构函数与构造函数功能相反，它是对资源的清理，相当于销毁函数，析构函数是在定义的对象生命周期结束时自动调用析构函数，完成对资源的清理，这样就算忘了调用销毁函数也不会造成内存泄漏了

析构函数特性：

1. 析构函数名是在类名前加 ~
2. 无参数，无返回值
3. 一个类只能有一个析构函数（不能重载，析构函数无参数），
   若是未显式定义，系统会自动生成默认析构函数。
4. 对象生命周期结束时，编译器会自动调用析构函数
   5.若是未显式定义，系统会自动生成默认析构函数（生成的默认析构函数和自动生成的构造函数类似(a.内置类型成员不做处理 b.自定义类型会调用它的析构函数））

以栈为例

#include<iostream>
using namespace std;
class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			perror("malloc fail
");
			return;
		}

		_top = 0;
		_capacity = capacity;

		cout << "_top=" <<_top<< ' ' << "_capacity="<<_capacity << endl;
	}

	~Stack()
	{
		free(_a);
		_a = nullptr;
		_top = 0;
		_capacity = 0;
		cout << "_top=" << _top << ' ' << "_capacity=" << _capacity << endl;
	}
	int _capacity;
	int* _a;
	int _top;
};

int main()
{
	Stack st1;

	return 0;
}

调试转到反汇编，可以发现，是在对象生命周期结束，自动调用析构函数
类中没有显式写析构函数，编译器会自动生成一个默认析构函数，其实和构造函数差不多

析构函数总结

一般情况下，如果对类成员写的是静态的，那么就不用写析构函数。有动态申请资源的，就需要显式写析构函数释放资源。

类中成员没有动态申请资源，不需要写析构函数
类中需要释放资源的成员都是自定义类型，不需要写析构函数