三、析构函数

3.1概念

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

3.2特性

析构函数是特殊的成员函数，其特征如下：

1、析构函数名是类名前加上字符~.(这个字符在C语言阶段是按位取反的意思)

2、无参数无返回值类型。

3、一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。

4、对象声明周期结束时，C++编译系统自动调用析构函数。

那么这个析构函数到底用不用我们去写呢？如果我们需要写，那么什么情况下写呢？

我们先来看一下编译器生成的默认析构函数，会进行什么操作：

class Time
{
public:
  ~Time()
  {
  cout << "~Time()" << endl;
  }
private:
  int _hour;
  int _minute;
  int _second;
};
class Date
{
private:
  //内置类型
  int _year = 2022;
  int _month = 9;
  int _day = 23;
  //自定义类型
  Time t1;
};
int main()
{
  Date d1;
  return 0;
}

我们看到，在这里系统自动调用了自定义类型Time类的析构函数。

析构函数的特征：

1、对于内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；

2、对于自定义类型成员，在结束时，系统会调用它的析构函数，目的在于当类对象销毁时，保证其内部每个自定义对象都可以正确销毁。

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

我们在编写时始终要面向需求：编译器默认生成的就可满足的话，就不用自己写，不满足就需要自己写。

四、拷贝构造函数

4.1概念

现实生活中，可能有的老铁有双胞胎兄弟。

那在创建对象时，可否创建一个与已存在对象一模一样的新对象呢？

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

一般拷贝构造函数的形式是 类(const 类& 别名 )

调用时： 类 要拷贝的类对象(被拷贝的类对象)

4.2 特征

拷贝构造函数也是特殊的成员函数，其特征如下：

1、拷贝构造函数时构造函数的一个重载形式。

2、拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用，具体来说传值时编译器会自动调用拷贝构造。

光说特性是有点抽象的，因为拷贝构造函数比较繁杂且内容较难，我将举大量例子来讲解。

我们先来看正确的拷贝构造是如何写的：

class Date
{
public:
  Date(int year = 1, int month = 1, int day = 1)
  {
  _year = year;
  _month = month;
  _day = day;
  }
  Date(const Date& d)//必须是Date的引用
  {
  cout << "Date 拷贝构造" << endl;
  _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;
}

下面我将对这个正确的拷贝构造进行拆解，并且分析错误的写法。

①传值传参拷贝构造

Date(Date d)
  {
  cout << "Date 拷贝构造" << endl;
  _year = d._year;
  _month = d._month;
  _day = d._day;
  }

这种形式为什么不可取？为什么必须是引用传参？

因为传值传参会引发无穷递归！为什么呢？我们知道传值调用不会改变原来的参数，它是实参的一份临时拷贝。问题就出在这个临时拷贝上了，它要拷贝实参，那么怎么拷贝？调用拷贝构造函数，那这个拷贝构造函数是怎么写的？传值传参拷贝构造，然后再次拷贝调用，无限递归循环，直到系统挂掉。

所以我们要传引用拷贝！对于这一点，这里可以举个例子印证传值传参会调用拷贝构造函数：

class Date
{
public:
  Date(int year = 1, int month = 1, int day = 1)
  {
  _year = year;
  _month = month;
  _day = day;
  }
  Date(const Date& d)
  {
  cout << "Date 拷贝构造" << endl;
  _year = d._year;
  _month = d._month;
  _day = d._day;
  }
private:
  int _year;
  int _month;
  int _day;
};
void Func1(Date d1)//传值传参，拷贝构造
{
  cout << "Func1()" << endl;
}
void Func2(Date& d2)
{
  cout << "Func2()" << endl;
}
int main()
{
  Date d1(2022, 9, 23);
  Func1(d1);
  Func2(d1);
  return 0;
}

按道理来说，编译器只有在拷贝构造函数的时候会调用这个函数，但是这里我们看到，我们只是传值传参，但是却调用了拷贝构造函数，在调用Func1()函数的时候调用了拷贝构造函数，但是调用Func2()函数没有调用拷贝构造函数，印证了传值传参不可取！

所以要传引用传参！

②不加const传引用拷贝

之前博主在介绍C++引用这一节的时候，强调过引用和指针要特别对待，因为它们都有可能改变原来参数(实参)的数据。如果有人不小心这样写拷贝构造函数呢？

Date(Date& d)//必须是Date的引用
  {
  cout << "Date 拷贝构造" << endl;
  _year = d._year;
  _month = d._month;
  d._day = _day;
  }

这样写会引发什么后果？它会导致实参的数据被修改。而这是无法接受的，编译也不会报错的，而且也难以察觉，因此我们要加const限制。

特征3：

若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

这里我们没写拷贝构造函数，但是确实拷贝成功了，这里对于内置类型进行了拷贝，自定义类型也进行了拷贝(因为会调用它的拷贝构造)。我们看到编译器自己生成默认的拷贝构造函数完成了拷贝任务。那么有的老铁可能要困惑，既然系统默认给的拷贝构造函数可以完成拷贝任务，那么我们还有必要去写拷贝构造函数吗？

我们来看这里

别的拷贝都没有问题，但是我们注意到这里st1的_a和st2的_a的地址也一模一样，这就会出问题，为什么呢？

它们是动态开辟的空间，地址一样代表指向同一块空间，但是这样的拷贝是不符合我们的预期的，因为我们想要拷贝同样大小，同样数据但是不一样的空间！

这里再往下运行它就会崩掉，在free崩掉，因为最后调用析构函数对同一块空间析构两次(free两次)会报错。

这里再说明一下：析构两次的话，st1和st2谁先析构？

这里是st2先析构，后定义的先析构，它符合栈的特点：后定义的先销毁。

st2先析构，st2的_a指向的空间销毁，_a置空，st1和st2的_a指向相同的空间，但是这个空间已经被销毁，所以是野指针，再次free会崩掉。

所以这里我们要自己手动写栈的拷贝构造

我们看出来，当涉及资源申请(动态开辟空间)的时候，拷贝构造函数是一定要写的，否则就是浅拷贝。我们将这种拷贝称为深拷贝，像栈，队列，二叉树，堆这种涉及申请开辟空间的都需要深拷贝。

注意：

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

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