类与对象
在C++中，类和对象的出现，是为了完善C语言的不足，在struct的基础上慢慢进步，慢慢完善，将其的功能发挥到最大，也方便使用！
类与对象可谓是非常的重要了，所以在这里我们分为几篇来学习类与对象，在接下来的学习中，我们需要反复琢磨，去好好复习，才能学的好，学的牢，学的扎实！
前言
有没有这种情况，在C语言阶段编写数据结构的时候，是不是多多少少会忘记初始化？？
结果定义以后，忘记Init？？在一顿操作以后，总会忘记destroy？？
对，我们多多少少会忘记，所以在C++类和对象中呢，就出现了这样的函数：构造函数和析构函数
一、🏠类的六个默认成员函数
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。
1.🚀构造函数
1.😯定义
构造函数，他不是真正去构造一个函数，只是向我们上面所说的，去初始化一个对象。
class Date { public: void 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(2022, 7, 5); d1.Print(); Date d2; d2.Init(2022, 7, 6); d2.Print(); return 0; }
对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置 信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？
构造函数 是一个 特殊的成员函数， 名字与类名相同 , 没有返回值 ， 创建类类型对象时由编译器 自动调用 ，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次 。
所以有了构造函数以后，就可以直接这样：
class Date { public: //构造函数 Data(int year, int month, int day) { _year = year; _month = month; _day = day; } ...... }; int main() { Date d1(2022, 7, 5); d1.Print(); Date d2(2022, 7, 6); d2.Print(); return 0; }
2.😯特征
构造函数可以重载（重载（点击链接有详细解释），函数名相同，参数不同就构成重载）
为什么要构成重载呢？ 目的是为了实现多种初始化的方式：
Date(int year, int month, int day) { _year = year; _month = month; _day = day; } Date() { _year = 0; _month = 0; _day = 0; } Date(int year=1, int month=1, int day=1) { _year = year; _month = month; _day = day; }
三种初始化的函数都构成函数重载，但是第二个和第三个却不能同时在一起使用，因为全缺省和无参数是一种情况，当调用时，会发生二义性，运行失败：
int main() { Date d1(2022, 7, 5); Date d2(2022, 7, 6); // 无参数时，要这样调用，不可以Data d3();，会与函数声明发生冲突 //，就相当于 Data func();，是错误的 Date d3; return 0; }
如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦
用户显式定义编译器将不再生成。
那么编译器自动生成的无参默认构造函数可以直接使用吗？
没有类中显示的构造函数，使用默认的构造函数：
class Date { public: void Print() { cout << _year << "-" << _month << "-" << _day << endl; } private: int _year; int _month; int _day; }; int main() { Date d1; d1.Print(); }
默认构造函数对内置类型不进行处理，只对自定义类型进行处理。
所以需要我们自己去写构造函数！
内置类型：语言自己提供的类型：int，double，char....
自定义类型：class/struct + stack/queue/person.... 类或者结构体等...
所以，我们自己不写，编辑器会自动生成，内置不处理，只处理自定义类型。
但是需要看需求才来决定是否需要自己写，不能光看内置类型还是自定义类型
面向需求：编译器默认生成就可以满足，就不用自己写，不满足就需要自己写
class Stack { public: Stack(int capacity = 4) { cout << "Stack(int capacity = 4)" << endl; _a = (int*)malloc(sizeof(int)*capacity); if (_a == nullptr) { perror("malloc fail"); exit(-1); } _top = 0; _capacity = capacity; } void Push(int x) { // .... // 扩容 _a[_top++] = x; } private: int* _a; int _top; int _capacity; }; class MyQueue { public: void push(int x) { _pushST.Push(x); } Stack _pushST; Stack _popST; //size_t _size; };
对于MyQueue这个类中，有Stack _pushST; Stack _popST;两个自定义类型，发现在MyQueue类中没有显示的构造函数，就会使用自定义类型默认的构造函数，回Stack中使用构造函数。
那么说不对内置类型处理，那如果成员变量中，既有内置类型，又有自定义类型，那应该怎么办？
利用缺省值来处理内置类型：
class MyQueue { public: void push(int x) { _pushST.Push(x); } Stack _pushST; Stack _popST; size_t _size=0; };
这样既有内置类型，又有自定义类型时，就可以调用构造函数初始化了。
2.🚀默认构造函数
无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为
是默认构造函数。
举例说明：
class Stack { public: Stack(int capacity = 4) { cout << "Stack(int capacity = 4)" << endl; _a = (int*)malloc(sizeof(int)*capacity); if (_a == nullptr) { perror("malloc fail"); exit(-1); } _top = 0; _capacity = capacity; } void Push(int x) { // .... // 扩容 _a[_top++] = x; } private: int* _a; int _top; int _capacity; }; class MyQueue { public: void push(int x) { _pushST.Push(x); } Stack _pushST; Stack _popST; size_t _size=0; //这里不是初始化，是缺省值 }; int main() { MyQueue q; return 0; }
在定义一个MyQueue类的 对象q时，类中没有已经写好的构造函数，就要使用编译器默认的构造函数，那么内置类型有缺省值，自定义类型也要使用默认构造函数，默认构造函数只有三种情况：无参构造函数、全缺省构造函数、我们没写默认给出的，stack类中，刚好时全缺省作为了默认构造函数，有默认构造函数，可以使用。
但如果改变一个条件，将stack缺省值去掉：
还可以使用吗?当然不可以！
首先，Queue类创建对象初始化时，我们发现Queue本身没有构造函数，那么他就会调用编译器提供的默认构造 ，内置类型不处理，但有缺省值，自定义类型调用默认构造，但发现Stack类中，没有默认构造函数（无参构造函数、全缺省构造函数、我们没写默认给出的），因为自己写了，stack类就不会自己提供。所以无法初始化。
若使用编译器自己提供的，能满足我们需求吗？
可以看出，默认提供的并没有将数组开辟空间，不能满足我们的需求。
结论：面向需求：编译器默认生成就可以满足，就不用自己写，不满足就需要自己写
那我们可不可以直接把 int* _a = (int*)malloc(sizeof(int)*4); malloc作为缺省值呢？
居然发现是可以的，但是有坏处是，无法调试他是否开辟成功。
3.析构函数
1.概念
那么定义类时，构造函数会自动初始化，
那结束时，有没有自动destroy，自动清理内存空间的函数呢？
当然有：
析构函数 ：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由
编译器完成的，而是 对象在销毁时会自动调用析构函数，完成对象中资源的清理工作 。
2.特性
1. 析构函数名是在类名前加上字符 ~ 。（~这个符号在C语言里面是二进制取反）
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。 注意：析构
函数不能重载，因为没有参数，所以不存在析构函数。
4. 对象 生命周期 结束时， C++ 编译系统系统自动调用析构函数。
析构函数在对象生命周期结束时自动调用，生命周期得具体看，如果在局部域（函数内部），则函数调用完毕后，就会结束局部变量的生命周期，全局域，malloc（手动结束）。
class Stack { public: //析构函数名是在类名前加上字符 ~ ~Stack() { free(_a); _a=nullptr; _top=_capacity=0; } private: int* _a; int _top; int _capacity; };
析构函数也是一样的，类比构造函数。如果自己没写，那么编译器就会自动生成，且内置类型不处理，自定义类型处理。就比如 int*_a,编译器他不清楚是一个单纯的指针，还是它指向动态内存空间，不知道应该怎么处理。
至于要不要自己写，就要看默认的，即编译器自动生成的满不满足我们的需求。
