hello，各位小伙伴，本篇文章跟大家一起学习《C++：构造函数、析构函数、拷贝构造函数》，感谢大家对我上一篇的支持，如有什么问题，还请多多指教 ！
文章目录
1. 构造函数构造函数特性 2. 析构函数析构函数的特性 3. 拷贝构造函数拷贝构造函数的特征
1. 构造函数
我们先来看下面这个类：
class Date{public:Init(int year,int month,int day){_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;};int main(){Date d1;d1.Init(1,1,1);d1.Print();return 0;}Date类的成员函数有一个Init()函数，用来初始化日期，但是我们需要显示调用这个函数，才能初始化我们实例化的对象d1，大家在下代码的时候是否会经常出现忘记初始化，如：在写栈的时候…等等，那么C++祖师爷 - 本贾尼也是否会忘记初始化呢？
没错，为了解决这个问题，祖师爷就弄了一个特殊的成员函数 -> 构造函数
构造函数特性
要注意：构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
构造函数：名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。
其特征如下：
函数名与类名相同。无返回值。 （连void都不需要写）对象实例化时编译器自动调用对应的构造函数。构造函数可以重载。 干说难懂，看代码：
class Date{public:// 名字与类名相同Date()// 无参的函数构造{}Date(int year,int month,int day)// 带参的构造函数{_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;};int main(){// 调用方式：Date d1;// 无参调用d1.Print();Date d2(2024,4,9);// 带参调用d2.Print();return 0;}注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明。
我们也可以写一个缺省构造函数，如：
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();d1.Print();return 0;}但是要注意：
class Date{public:// 无参构造函数Date(){_year = 1;_month = 1;_day = 1;}// 全缺省构造函数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;d1.Print();return 0;}无参构造函数和全缺省构造函数构成函数重载，但是Date d1;这么写的时候编译器会报错，不知道该调用哪一个构造函数，一定要注意。
错误 C2668 “Date::Date”: 对重载函数的调用不明确
构造函数第5个特征：
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
class Date { public: /* // 如果用户显式定义了构造函数，编译器将不再生成 Date(int year, int month, int day) { _year = year; _month = month; _day = day; } */ void Print() { cout << _year << "-" << _month << "-" << _day << endl; } private: int _year;int _month; int _day; }; int main() { Date d1; return 0; }将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
关于编译器生成的默认成员函数，很多小伙伴们会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？
d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值(VS2020编译器)。也就说在这里编译器生成的默认构造函数并没有什么用？？
解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。
内置类型没有规定要处理(可处理，可不处理，看编译器)
class Time{public:Time(){cout << "Time()" << endl;_hour = 0;_minute = 0;_second = 0;}private:int _hour;int _minute;int _second;};class Date{private:// 基本类型(内置类型)int _year;int _month;int _day;// 自定义类型Time _t;};int main(){Date d;return 0;}可以看到编译器调用了Time()函数，但是不是觉得很奇怪，对内置类型没有规定要处理(可处理，可不处理，看编译器)，只对自定义类型进行处理，但是自定义类型的尽头是内置类型，所以C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。
class Date{private:// 基本类型(内置类型)int _year = 1970;int _month = 1;int _day = 1;};int main(){Date d;return 0;}无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为
是默认构造函数。
2. 析构函数
通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
析构函数的特性
析构函数是特殊的成员函数，其特征如下：
void)一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载对象生命周期结束时，C++编译系统系统自动调用析构函数。 对于上面用例Date类，需不需要用显示写析构函数呢？
换一种问法，Date类中有没有资源需要清理呢？没有，所以不需要。
如下述代码就需要：
typedef int STDataType;class Stack{public:Stack(const Stack& st1){_capacity = st1._capacity;_top = st1._top;_a = (STDataType*)malloc(sizeof(STDataType)*st1._capacity);memmove(_a, st1._a, sizeof(STDataType) * st1._top);}bool Empty(){return _top == 0;}int Size(){return _a[_top];}Stack(){_a = NULL;_capacity = 0;_top = 0;}~Stack(){free(_a);_a = NULL;_top = _capacity = 0;}void Push(STDataType data){if (_top == _capacity)//空间满了{int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));assert(tmp);_a = tmp;_capacity = newcapacity;}_a[_top] = data;_top++;}void Pop(){assert(!Empty());_top--;}STDataType Top(){assert(!Empty());return _a[_top - 1];}private:int _capacity;STDataType* _a;int _top;};int main(){Stack s1;s1.Push(1);s1.Push(2);s1.Push(1);Stack s2 = s1;cout << s2.Top() << endl;return 0;}没错，就是栈，我们自行写代码练习的时候，难免会忘记释放动态内存的空间吧，会造成内存泄漏，虽然内存泄漏编译器不会报错，但是这种小问题越积越多的时候，就会演变成大问题。
关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器
生成的默认析构函数，对自定类型成员调用它的析构函数。
class Time{public:~Time(){cout << "~Time()" << endl;}private:int _hour;int _minute;int _second;};class Date{private:// 基本类型(内置类型)int _year = 1970;int _month = 1;int _day = 1;// 自定义类型Time _t;};int main(){Date d;return 0;}程序运行结束后输出：~Time()
我们看到，在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
解答：因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month, _day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是：main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数。
注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数
析构函数总结：如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。
3. 拷贝构造函数
拷贝构造函数顾名思义，用来拷贝的，但是只是用来拷贝对象的。
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。
拷贝构造函数的特征
拷贝构造函数也是特殊的成员函数，其特征如下：
class Date{public: Date(int year = 1900, int month = 1, int day = 1) { _year = year; _month = month; _day = day; } // Date(const Date& d) // 正确写法 Date(const Date d) // 错误写法：编译报错，会引发无穷递归 { _year = d._year; _month = d._month; _day = d._day; }private: int _year; int _month; int _day;};int main(){ Date d1; Date d2(d1); return 0;}为什么会引无穷递归呢？
解答：对象在传值传参时会引发对象的拷贝，如图引发无穷递归
若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
class Time{public:Time(){_hour = 1;_minute = 1;_second = 1;}Time(const Time& t){_hour = t._hour;_minute = t._minute;_second = t._second;cout << "Time::Time(const Time&)" << endl;}private:int _hour;int _minute;int _second;};class Date{private:// 基本类型(内置类型)int _year = 1970;int _month = 1;int _day = 1;// 自定义类型Time _t;};int main(){Date d1;// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数Date d2(d1);return 0;}根据调试可以看到，d2成功拷贝
注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
义类型是调用其拷贝构造函数完成拷贝的。
小编内心：那是不是很爽啊，编译器都帮我拷贝了，那我就不需要自己写拷贝构造函数了？
编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？
当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？
typedef int STDataType;class Stack{public:bool Empty(){return _top == 0;}int Size(){return _a[_top];}Stack(){_a = NULL;_capacity = 0;_top = 0;}~Stack(){free(_a);_a = NULL;_top = _capacity = 0;}void Push(STDataType data){if (_top == _capacity)//空间满了{int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));assert(tmp);_a = tmp;_capacity = newcapacity;}_a[_top] = data;_top++;}void Pop(){assert(!Empty());_top--;}STDataType Top(){assert(!Empty());return _a[_top - 1];}private:int _capacity;STDataType* _a;int _top;};int main(){Stack s1;s1.Push(1);s1.Push(2);s1.Push(3);s1.Push(4);Stack s2(s1);return 0;}呀，编译器崩溃了，为什么啊？这里就需要我们以后讲的深拷贝去解决。
我们调试看到，拷贝是成功拷贝了：
前面我们说过：编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了
所以s2._a所指向的空间就是s1._a所指向的空间，在程序运行完成后，编译器会销毁该空间(s2先销毁)，也就是free掉s2._a，然后再free掉s1._a，那么同一块空间就释放了两次，那肯定会报错
拷贝构造函数总结：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
拷贝构造函数典型调用场景：
使用已存在对象创建新对象函数参数类型为类类型对象函数返回值类型为类类型对象class Date{public:Date(int year, int minute, int day){cout << "Date(int,int,int):" << this << endl;}Date(const Date& d){cout << "Date(const Date& d):" << this << endl;}~Date(){cout << "~Date():" << this << endl;}private:int _year;int _month;int _day;};Date Test(Date d){Date temp(d);return temp;}int main(){Date d1(2022, 1, 13);Test(d1);return 0;}
看到结果是不是感觉很乱，来看解释：
所以，为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。
好啦，这篇文章就到此结束了
所以你学会了吗？
好啦，本章对于《C++：构造函数、析构函数、拷贝构造函数》的学习就先到这里，如果有什么问题，还请指教指教，希望本篇文章能够对你有所帮助，我们下一篇见！！！
如你喜欢，点点赞就是对我的支持，感谢感谢！！！
