1.类的六个默认成员函数

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

但是空类中真的什么都没有吗？其实并不是，任何一个类在我们不写任何成员的情况下，都会生成如下 六个默认成员函数 ： 它们是特殊的成员函数：如果自己没有实现，编译器会自己生成，不一定效果最佳，但有一定价值。

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

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

2.构造函数

就拿日期类来说：

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;
  }
};

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

2.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.2 特性

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

基本特征 如下：

1.函数名与类名相同。

2.无返回值。

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

4.构造函数可以重载。

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

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

编译器默认生成的构造函数为空函数。C++ 中把类型分为两类

1.内置类型（基本类型：int/char/double/内置类型数组）

2.自定义类型（struct/class/联合定义的类型）。

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

默认构造函数：全缺省构造函数或者无参构造函数

编译器自动生成的构造函数机制：

 1、编译器自动生成的构造函数对内置类型不做处理。

 2、对于自定义类型，编译器会再去调用它们自己的默认构造函数。

总结：虽然在我们不写的情况下，编译器会自动生成构造函数，但是编译器自动生成的构造函数可能达不到我们想要的效果，所以大多数情况下都需要我们自己写构造函数。

若用户定义了构造函数，则编译器不生成默认无参构造函数，若调用方式错误，则会报错 去掉无参构造 ：

总结：C++ 中编译器默认生成构造函数，但没有对内置类型与自定义类型统一处理（不处理内置类型成员变量，只处理自定义类型成员变量） 所以在 C++ 11 时，对于内置类型打了一个补丁：内置类型成员变量在类中声明时可以给默认值（缺省值）

一般情况下，构造函数都需要我们自己写，但以下两种情况，可以不用：

a.内置类型成员都有缺省值，且初始化符合我们的要求 b.全是自定义类型的构造，且都定义默认构造

3.析构函数

通过前面构造函数的学习，我们知道一个对象是怎么初始化的，那一个对象又是怎么清理的？

3.1 概念

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

3.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;
}

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

我们知道构造是 d1 先构造，再构造d2 ，但是析构的顺序呢？对于在栈帧中的对象，因为 d1 先压栈，d2 再压栈，所以会先出 d2 ，就先对 d2 进行析构，它们的析构顺序与构造顺序是相反的 若没有定义析构函数，则编译器会自动生成，但是自动生成的析构函数会干什么？它会销毁栈吗？ 并不会。

析构函数对于内置类型的成员变量不做处理，对于自定义类型会去调用它的析构函数

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

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

而对于自定义类型的成员变量去调用它的析构函数是很有用的，就比如这题：232. 用栈实现队列。之前用 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++编译系统自动调用析构函数

4.拷贝构造函数

对于内置类型，编译器可以直接对数据完成拷贝；但是在对自定义类型进行拷贝时，编译器是不适合直接拷贝的，而这时可以使用拷贝构造函数。

4.1 概念

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

4.2 特性

拷贝构造函 数是特殊的成员函数 。它的名字也为类名，和构造函数构成函数重载，且必须使用传引用传参，使用传值传参会报错：

验证传值传参报错： 一定要加上引用才不会报错 ： 拷贝构造函数的参数只有一个且必须是类的类型对象的引用，使用 传值方式 编译器 直接报错 ，因为这会引发无穷递归调用；这是拷贝构造函数的特性之一，如何理解会引发无穷递归调用？ 仔细观察拷贝构造函数传参的过程，重复出现 Date date(d1) ，在传参时，是不是无形中又调用了拷贝构造函数？

因为我们的 date 形参就是原对象 d1 ，而传参过来，则是一份和原先对象一模一样的对象，这个对象不存在，所以我们需要先进行拷贝构造，而拷贝构造到下一层也是相同的原理，就是在一直拷贝构造不存在的形参，从而形成死递归 。

但是使用引用传参就没事了，因为 date 此刻变为 d1 的别名，这时就不存在 拷贝对象不存在从而继续拷贝的情况 。此刻就可以顺利进入拷贝构造函数。

所以拷贝构造参数一定不能为传值，要传引用！我们也可以抽象出一个概念：自定义类型传值传参就是拷贝构造 。

而对于拷贝构造函数的参数，一般加 const 修饰 ，因为拷贝构造函数的功能可能会写反，比如：

Date(Date& d) // 拷贝构造函数
{
    d._year = _year; // 写反了
    d._month = _month;
    d._day = _day;
}

这时不仅没有拷贝构造成功，还把 d1 改了： 这就错误了，但是加上 const 修饰便会发现问题： 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象内存存储按 字节序 完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

当 Date 类没有拷贝构造函数时，仍然按照字节序完成了值拷贝

但是对于 Stack 类就不行：

class Stack
{
public:
  Stack(int capacity = 4)
  {
    _array = (int*)malloc(sizeof(int) * capacity);
    if (_array == nullptr)
    {
      cout << "malloc fail" << endl;
      exit(-1);
    }
    _top = 0;
    _capacity = capacity;
  }
  void Push(const int& data) 
  {
    _array[_top] = data;
    _top++;
  }
  ~Stack()
  {
    free(_array);
    _array = nullptr;
    _top = _capacity = 0;
  }
private:
  int* _array;
  size_t _top;
  size_t _capacity;
};
int main()
{
  Stack st1;
  st1.Push(1);
  Stack st2(st1);
  return 0;
}

当我们进行操作时，程序奔溃了 因为 st1 和 st2 指向的同一块空间，释放了两次。

这里我们使用的默认拷贝构造就是编译器自动处理的，很明显这里不行。而如果要实现正确的拷贝构造，需要深拷贝。所谓深拷贝，就是让它们有独立的空间，就比如这里的 Stack ，就是让 _array 指向不同的空间，使得它们之间的操作互不影响，接下来，我们简单写一下深拷贝：

class Stack
{
public:
  Stack(int capacity = 4)
  {
    _array = (int*)malloc(sizeof(int) * capacity);
    if (_array == nullptr)
    {
      cout << "malloc fail" << endl;
      exit(-1);
    }
    _top = 0;
    _capacity = capacity;
  }
  Stack(const Stack& st)
  {
    _array = (int*)malloc(sizeof(int) * st._capacity);
    if (_array == nullptr)
    {
      cout << "malloc fail" << endl;
      exit(-1);
    }
    memcpy(_array, st._array, sizeof(st._array) * st._top); // 拷贝 st1 指向空间的值到 st2 指向的空间
    _top = st._top;
    _capacity = st._capacity;
  }
  void Push(const int& data)
  {
    _array[_top] = data;
    _top++;
  }
  ~Stack()
  {
    free(_array);
    _array = nullptr;
    _top = _capacity = 0;
  }
private:
  int* _array;
  size_t _top;
  size_t _capacity;
};

这时就没有问题了，st1 和 st2 指向了不同的空间： 结论：当自己实现了析构函数释放空间，就需要实现拷贝构造（深拷贝），深拷贝我们之后会详细学习。可以理解为拷贝构造是为自定义类型的深拷贝而生的

如果此时使用浅拷贝，就会存在两个问题：1.析构函数释放空间两次，报错 2.一个修改值，另一个也会被影响 特性 ：

拷贝构造函数是 构造函数的一个重载形式 。

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

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

只要自定义构造函数或者拷贝构造函数，都不会生成构造函数，自定义类型成员会调用它的拷贝构造。

总结：拷贝构造当我们不写，生成的默认拷贝构造函数对于内置类型和自定义类型都会拷贝处理。但是处理细节与构造和析构是不一样的。