一、前言

上篇文章中，我们对类和对象做了一个简单入门。今天，我们将深入学习类和对象的六个默认成员函数，分别为：构造函数、析构函数、拷贝构造函数、赋值操作符重载、取地址与const取地址操作符重载 。当我们学习完这六个默认成员函数，类和对象基本就筑基了，学会了今天的内容，对于接下来的最后一篇类和对象就是补充补充，打打补丁了，对于之后的学习，我们也会轻松很多。

所以今天的内容很重要，但是也很多，很杂，有一定难度。所以打起精神，让我们开始学习！

这次仍然围绕日期类进行讲解，首先写出日期类：

class Date
{
private:
  int _year;
  int _month;
  int _day;
public:
  void Init(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void Print()
  {
    cout << _year << '-' << _month << '-' << _day << endl;
  }
};

二、类的六个默认成员函数

我们讲过，当类中一个成员没有时，则为空类。

但是空类中真的什么都没有吗？其实并不是，任何一个类在我们不写任何成员的情况下，都会生成如下 六个默认成员函数 ：

它们是特殊的成员函数，特殊的点很多：如果自己没有实现，编译器会自己生成，不一定效果最佳，但有一定价值。

它们的作用很强大，比如写 C 语言时，写一个栈，可能一顿操作猛如虎，但是忘记初始化和销毁，不是崩溃就是内存泄漏。C++ 针对这种情况设计了构造函数（初始化）和析构函数（清理）。

同理，其他成员函数也都是根据场景设计，弥补 C 中的不足。

三、构造函数

就拿日期类来说：

class Date
{
private:
  int _year;
  int _month;
  int _day;
public:
  void Init(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void Print()
  {
    cout << _year << '-' << _month << '-' << _day << endl;
  }
};

我并没有写构造函数，那么这个日期类存在析构函数吗？存在。

1、概念

对于Date类，可以通过 Init 成员函数给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？当然可以，就是用构造函数。

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

我们来动手写一下：

class Date
{
public:
  Date()
  {
    _year = 0;
    _month = 1;
    _day = 1;
  }
  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(2023, 1, 31); // 传参调用第二个构造函数
  return 0;
}

构造函数名称和类名相同，所以名字为 Date ，函数无返回值。

构造函数会自动调用；若需要主动调用，只要 Date() 即可，括号中为参数。

验证没问题，d1 被自动调用，d2 主动调用，两者都初始化完毕；它们互不冲突，且构成函数重载 。而两个函数其实有些繁琐，根据 缺省参数 的特性，我们发现其实这两个函数可以合并成一个函数：

Date(int year = 0, int month = 1, int day = 1)
{
    _year = year;
    _month = month;
    _day = day;
}
// 调用
Date d1;
Date d2(2023, 1);
Date d3(2023, 1, 31);

使用全缺省参数，使调用更加多样。但是使用这种实现方式，须注意二义性 ，例如这里再写一份无参的构造函数 Date() ，就会造成二义性，语法能编译通过，但是调用不知道调用哪一个。

2、特性

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

其 基本特征 如下：

       函数名与类名相同。

       无返回值。

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

       构造函数可以重载。

还有几个较难的特征，我们一一讲解：

   5）如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数；一旦用户显式定义，编译器将不再生成默认无参构造函数

编译器默认生成的构造函数为空函数。C++ 中把类型分为两类，内置类型（基本类型：

int/char/double/内置类型数组），自定义类型（struct/class定义的类型）。

当我们不写构造函数时，对于内置类型不做初始化处理，对于自定义类型会调用它自动生成的默认构造函数（不用参数就可以调用）构造初始化（先对成员进行构造，再对整体进行构造）。但是如果没有默认构造函数就报错。

   下面我们验证：若用户定义了构造函数，则编译器则不生成默认无参构造函数，若调用方式错误，则会报错。

class A
{
public:
  A()
  {
    cout << "A()" << endl;
    _a = 0;
  }
private:
  int _a;
};
class Date
{
public:
  Date(int year = 0, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
private:
  int _year;
  int _month;
  int _day;
    A _aa;
};
int main()
{
  Date d1;
  return 0;
}

在 Date 类的成员变量中，创建 A 的类对象，且 A 具有无参构造函数。

在当前情况下，执行是没问题的，其一是因为 d1 调用其构造函数，需要将 自定义类型 _aa 初始化；其二是 _aa 又会调用其默认构造函数，此刻因为 A 定义的 构造函数无参 ，A _aa 可以通过编译，并调用构造函数打印，完成初始化。

但是如果给 A 的构造函数增加参数 ：

就报错了，因为此刻 _aa 没有默认构造函数调用，且由于自定义了构造函数，编译器也没有自动生成 。

总结：C++ 我们不写编译器默认生成构造函数，函数设计的不好，没有对内置类型与自定义类型统一处理（不处理内置类型成员变量，只处理自定义类型成员变量）

所以在 C++ 11 时，对于内置类型打了一个补丁：内置类型成员变量在类中声明时可以给默认值（缺省值）

_year 给了 100 ，所以有值，其他的没有给，所以用默认值（缺省值）。

6）无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个（无参构造函数、全缺省构造函数、没写编译器默认生成的构造函数，都可以认为是默认构造函数）

四、析构函数

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没的？

1、概念

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

2、特性

析构函数的函数名是在类名前加上字符 ~ ，例如基于 Date 类写一个析构函数：

~Date()
{
    // Date 类没有资源需要清理，所以当前 Date 类不写闲析构函数都可以
    cout << "~Date()" << endl;
}

析构函数无参、无返回类型，因此，析构函数 不构成函数重载 ，因为函数无参，所以一个类只能有一个析构函数 。

虽然 Date 类不需要析构函数，但是有的情景下就需要，比如 Stack（栈），我们简单写一个栈类：

class Stack
{
public:
  Stack(int capacity = 4) // 构造函数，缺省1参数，不传参默认给 4
  {
    _a = (int*)malloc(sizeof(int) * capacity);
    if (_a = nullptr)
    {
      cout << "malloc fail" << endl;
      exit(-1);
    }
    _top = 0;
    _capacity = capacity;
  }
private:
  int* _a;
  size_t _top;
  size_t _capacity;
};
int main()
{
  Stack s1;
  Stack s2;
  return 0;
}

对于栈来说，就需要析构函数，因为对于 s1, s2 为 main 中局部变量，但是它们指向的空间是 malloc 动态开辟的，所以必须释放，否则会造成内存泄漏。

所以必须写出析构函数 ：

~Stack()
{
    free(_a);
    _a = nullptr;
    _top = _capacity = 0;
}

通过析构函数来完成栈的销毁，而当局部变量出作用域时，系统会自动调用析构函数 ：

我们知道构造是 s1 先构造，再构造 s2 ，但是析构的顺序呢？，对于在栈帧中的对象，因为 s1 先压栈，s2 再压栈，所以会先出 s2 ，就先对 s2 进行析构，它们的析构顺序是相反的 ，观察 this 指针 ：

若没有定义析构函数，则编译器会自动生成，但是自动生成的析构函数会干什么？它会销毁栈吗？ 并不会。析构函数对于内置类型的成员变量不做处理，对于自定义类型会去调用它的析构函数。

   可能有小伙伴会疑惑，C++ 为什么多此一举搞自动生成析构函数，它又不对内置类型处理，没什么用啊？

其实也不能这么说，因为对于内置类型，就拿指针来说：

假设拿栈来说，这个指针就是要被释放，置空；如果我一看到指针都释放，都默认用 free ，如果不是 free 了不是动态开辟的指针呢？那不完了，所以对内置类型不处理这时反而是保护我们的程序。

而对于自定义类型的成员变量去调用它的析构函数是很有用的，就比如这题：

之前用 C 语言实现时，我们需要对其完成初始化，手动销毁，但是现在就不用了，我们完全可以通过构造函数和析构函数的特性来完成自动处理 ：

class Stack
{
public:
  Stack(int capacity = 4) // 构造
  {
    _a = (int*)malloc(sizeof(int) * capacity);
    if (_a = nullptr)
    {
      cout << "malloc fail" << endl;
      exit(-1);
    }
    _top = 0;
    _capacity = capacity;
  }
  ~Stack() // 析构
  {
    free(_a);
    _a = nullptr;
    _top = _capacity = 0;
  }
private:
  int* _a;
  size_t _top;
  size_t _capacity;
};
class MyQueue
{
public:
  void push(int x) {}
private:
  Stack pushST;
  Stack popST;
};
int main()
{
  MyQueue mq; // 自动调用构造和析构
  return 0;
}

这时对于自定义类型 mq ，就不用写了。因为对于默认生成的构造函数和析构函数，会自动调用它的构造和析构。这个自定义类型是 Stack ，于是就会自动调用，自动完成初始化和销毁。所以其实默认的析构函数还是很有用的！

总结 ：

       析构函数名是在类名前加上字符 ~

       无参数无返回值类型

       一个类只能有一个析构函数（无参不构成重载）; 若未显式定义，系统会自动生成默认的析构函数

       对象生命周期结束时（局部变量出作用域），C++编译系统自动调用析构函数