在学C语言时，实现栈和队列时容易忘记初始化和销毁，就会造成内存泄漏。而在C++的类中我们忘记写初始化和销毁函数时，编译器会自动生成构造函数和析构函数，对应的初始化和在对象生命周期结束时清理资源。那是什么是默认构造函数呢？例如在一个空类中，编译器会自动生成六个默认函数。默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。
目录
构造函数
构造函数的特性：
析构函数
拷贝构造函数
构造函数
概念：是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证 每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。
构造函数的特性：
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦 用户显式定义编译器将不再生成。
7、无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为 是默认构造函数。
示例：
class Student {
public:
Student()
{
cout << "Student()" << endl;
}
private:
int age;
};
int main()
{
Student s1;
}运行结果：
创建一个Student对象，我们并未调用初始化函数，编译器自动调用了默认构造函数Student（），这个虽然是我们自己写的，但是也是默认构造函数。
注意：无参的构造函数和全缺省函数都可以称为默认构造函数，并且默认构造函数只能有一个。编译器自动生成的也是一个默认构造函数，所以有三个默认构造函数。
那么在没有写构造函数下，编译器自动生成的默认构造函数会对内置类型以及自定义类型初始化吗？
示例：
class Stack {
private:
int* _a;
int _top;
int _capacity;
};
class Student {
public:
Student()
{
cout << "Student()" << endl;
}
private:
int age;
Stack s;
};
int main()
{
Student st1;
return 0;
}通过调试看一下编译器自动生成的默认构造函数是否对 age和s初始化：
从这里可以看出都进行了初始化，其实不然，如果只有内置类型的话就不初始化了，小编用的是VS2019，编译器不同是否初始化也不同，所以在写代码时不能依赖编译器自动生成的默认构造函数，还是自己手动写更好。
这是只用age变量时的结果 ：
总结：编译器自动生成的默认构造函数，对于内置类型不做处理 （但是我们可以在声明时给值），而对于自定义类型会去调用它自己的默认构造函数。
所以一般情况下构造函数都需要我们自己写，除非以下两种情况：
1、 内置类型成员都有缺省值，且符合预期值。
2、全是自定义类型成员，且自定义类型成员都有构造函数。
析构函数
概念：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由 编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作
析构函数特征：
1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构 函数不能重载。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
示例：
class Stack {
public:
Stack()
{
cout << "Stack()" << endl;
_a = (int*)malloc(sizeof(int) * 4);
if (_a == nullptr)
{
perror("malloc fail");
return;
}
_capacity = 4;
_top = 0;
}
~Stack()
{
cout << "~Stack" << endl;
free(_a);
_a = nullptr;
_capacity = _top = 0;
}
private:
int* _a;
int _top;
int _capacity;
};
int main()
{
Stack s1;
return 0;
}运行结果：
这里都会自动调用析构函数来清理资源，那么问题来了，是每次都需要写析构函数吗？
析构函数就和之前对动态空间释放一样，对于内置类型变量并没有处理，因为它们在栈上开辟的空间，在程序生命周期结束会自动销毁，而向系统申请的空间不一样，是开辟在堆上的，不能自动释放，只能手动释放空间，所以有以下三种情况：
1、一般情况下，有动态资源申请，就需要显示写析构函数。
2、没有动态资源申请，不需要写析构函数。
3、需要资源释放的都是自定义成员，不要写析构函数。
拷贝构造函数
概念：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存 在的类类型对象创建新对象时由编译器自动调用。
如果形参是值传递，那么会产生什么结果？
示例：
class Student {
public:
Student(int age = 18)
{
cout << "Student()" << endl;
_age = age;
}
Student(const Student s)//报错
{
_age = s._age;
}
Student(const Student& s)//正确写法
{
_age = s._age;
}
private:
int _age;
};
int main()
{
Student s1(20);
Student s2(s1);
return 0;
}这里会报错，形成无穷递归，传值调用时会先调用Student（Student s），因为传值所以会再一次调用，循环往复，所以报错了，可以通过一下示例来加深理解：
这里进行调试，在准备进入test函数时观察是否进入了test函数：
这里可以观察到在准备进入test函数时却进入Student函数，所以如果在Student函数的形参的传递是值传递，那么就会无穷递归。
C++规定：内置类型可以直接拷贝，自定义类型必须调用拷贝构造完成拷贝。
拷贝构造函数特征：
1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错， 因为会引发无穷递归调用。
3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按 字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
对于内置类型的拷贝可以不用写拷贝构造函数，但是对于自定义类型需要自己写拷贝构造函数
示例：
class Stack {
public:
Stack()
{
cout << "Stack()" << endl;
_a = (int*)malloc(sizeof(int) * 4);
if (_a == nullptr)
{
perror("malloc fail");
return;
}
_capacity = 4;
_top = 0;
}
~Stack()
{
cout << "~Stack" << endl;
free(_a);
_a = nullptr;
_capacity = _top = 0;
}
private:
int* _a;
int _top;
int _capacity;
};
int main()
{
Stack st1;
Stack st2(st1);
return 0;
}这段代码没有写拷贝构造函数，看看会出现什么结果：
这是什么问题呢？看不出可以调试看一下：
通过调试可以看出，两个对象的_a的地址相同，也就是说指向了同一块空间，当指向同一块空间时，会对该空间进行两次析构，所以程序崩溃了。
这时就需要我们自己来写拷贝构造函数，不可以依赖编译器自动生成的拷贝构造函数。
正确代码：
class Stack {
public:
Stack()
{
cout << "Stack()" << endl;
_a = (int*)malloc(sizeof(int) * 4);
if (_a == nullptr)
{
perror("malloc fail");
return;
}
_capacity = 4;
_top = 0;
}
~Stack()
{
cout << "~Stack" << endl;
free(_a);
_a = nullptr;
_capacity = _top = 0;
}
Stack(const Stack& st)
{
_a = (int*)malloc(sizeof(int) * st._top);
if (_a == nullptr)
{
perror("malloc fail");
return;
}
_capacity = st._capacity;
_top = st._top;
}
private:
int* _a;
int _top;
int _capacity;
};
int main()
{
Stack st1;
Stack st2(st1);
return 0;
}运行结果：
这就是自定义类型的深拷贝，当然深拷贝的知识不止这一点点，关注博主后续给你带来C++更多知识。
