🚀 本节重难点：构造、析构、拷贝构造(提炼的比较长)

1、构造函数最底层的初始化归根结底还得我们去写，但是如果我们在一个类型里面自定义类型并且这个自定义类型里面有初始化函数，那么在初始化时编译器就会自己调用。

2、对于没有动态开辟空间的类，不需要我们去写它的析构函数，对于有动态开辟内存的，我们需要去写它的析构函数释放空间。

3、拷贝构造函数要传引用，不能传值传参，因为会无穷递归拷贝构造，系统崩掉，而且引用要加const限制，防止对实参修改。

4、当不涉及动态开辟空间时，我们不需要自己写拷贝构造函数，用系统默认的拷贝构造函数即可。

一、类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。

空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

二、构造函数

2.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公有方法给对象设置日期，但如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。

2.2特性

构造函数是特殊的成员函数，需要注意的是，构造函数尽管名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

其特征如下：

1、函数名与类名相同。

2、无返回值。

3、对象实例化时编译器自动调用对应的构造函数。

4、构造函数可以重载。

简单来说，构造函数是一个特殊的成员函数，如果我们对这个类进行了初始化，编译器就不会再生成构造函数，如果我们没有写，编译器会自行默认生成。

①自行初始化

一般我们自己在写初始化的时候，通常有两种初始化方式：

1、无参构造函数；

2、带参构造函数。

class Date
{
public:
  //1.无参构造函数
  Date()
  {
  _year = 2022;
  _month = 9;
  _day = 23;
  }
  //2.带参构造函数
  Date(int year, int month, int day)
  {
  _year = year;
  _month = month;
  _day = day;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1;//调用无参构造函数
  Date d2(2022, 9, 23);//调用带参构造函数
  return 0;
}

其实我们这里还有第三种构造方式，但是它是内含于第二种构造方式：

带全缺省构造函数

Date (int year=2022,int month=9,int day=23)
{
    _year=year;
    _month=month;
    _day=day;
}

如果我们不传参就是按照缺省值来初始化，如果我们传参了，就按实参初始化。

注意：这里不要这样初始化：

Date d3();

这样初始化会一个问题：这是函数声明还是初始化？

②编译器初始化

那么如果我们没有写构造函数，编译器是如何初始化呢？我们可以看一下：

这个结果，是否让大家大吃一惊，相信老铁刚看到这个结果的时候，和博主一样，这也叫自己构造初始化？😂大家先别着急，C++对于这一点确实做得不够好，但是这里还有一些性质需要我们去了解。

C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，例如：int/char/double...，自定义类型就是我们使用class/struct/union等自己定义的类型。但是C++对于内置类型和自定义类型做了区别对待：我们来看以下代码：

class A
{
public:
  A()
  {
  cout << "A()构造函数" << endl;
  _a = 0;
  }
private:
  int _a;
};
class Date
{
public:
  void Print()
  {
  cout << _year << "-" << _month << " " << _day << endl;
  }
private:
  //内置类型
  int _year;
  int _month;
  int _day;
  //自定义类型--会去调用它的构造函数
  A a1;
};
int main()
{
  Date d1;
  d1.Print();
  return 0;
}

看到这个结果，不知道老铁意识到什么没有，在这里编译器做了一件什么事情？

对于内置类型，编译器就赋予随机值，对于自定义类型，编译器会自动调用它的构造函数！

对于这个概念，老铁可能仍旧疑惑，这有什么用？我在这里引用一个实际的题目再来说明一下：之前博主写过一期栈和队列oj题目详解，其中有一道题目是用栈实现队列：

leetcode：232、用栈实现队列

当时博主是用C语言写的，这里我们用C++来写的话，如果在我们要实现的队列里引入自定义类型栈，那么我们就不需要自己调用栈的构造函数对这个栈初始化。我这里还是把代码引入吧：

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);
  }
private:
  Stack _pushST;
  Stack _popST;
};
int main()
{
  MyQueue mq;
  mq.push(1);
  mq.push(2);
  return 0;
}

这里可以看到我的队列MyQueue里面只有自定义类型，没有内置类型，博主为了方便观察，在Stack的构造函数里面加入了打印，这里我并没有调用栈的构造函数，我们来看一下结果：

我们发现什么？编译器自己调用了栈的构造函数！所以这道题目如果用C++的方式还是比较方便的，也看出我们C++的设计还是可圈可点的。

可能有的老铁觉得，这栈里面的构造函数不还是我们写的吗？当然，毕竟编译器不是万能的，它能代我们执行初始化已经不错了。

补充：对于大家比较诟病的C++对于内置类型不处理的问题，在C++11打了补丁：

内置类型成员变量在类中声明时可以给默认值。也就是可以给缺省值。

具体怎么给呢，我给出几个例子：

我们这里给了内置类型缺省值也是可以初始化。

当然这里还有更神奇的地方：它甚至可以给动态开辟空间：

总结一下构造函数：

1、构造函数对内置类型不做处理。

2、对于类里面的自定义类型，会调用自定义类型的构造函数，如果没有就不对自定义里的成员变量处理。

3、如果这个自定义类型里的没有构造函数，就是默认构造，那么它的内置类型也是随机值。

4、所以最底层的初始化归根结底还得我们去写，但是如果我们在一个类型里面自定义类型并且这个自定义类型里面有初始化函数，那么在初始化时编译器就会自己调用。