(C++类的初始化和清理)构造函数与析构函数

在这里插入图片描述

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

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

class Date {};

但是这并不代表空类里面什么都没有，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

在这里插入图片描述

2. 构造函数（Constructor）

2.1 概念

对于以下的Data类，我们平常要通过手动给Init赋值，但是如果我们利用构造函数，就能在对象创建时，自动将信息设置进去。

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

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

2.2 特性

构造函数的主要作用是初始化对象，不是开空间创建对象
它有如下几个特征：
1️⃣函数名与类名相同(类名是 Date，构造函数名就是 Date)
2️⃣无返回值(因为不具有返回类型)
3️⃣对象实例化时自动调用相对应的构造函数
4️⃣构造函数可以重载
5️⃣无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

代码实现：
下面的代码只需要 Date d1，d2，就会自动调用构造，就能保证对象一定是被初始化过的

  class Date
 {
  public:
      // 1.无参构造函数
      Date()
     {}
  
      // 2.带参构造函数
      Date(int year, int month, int day)
     {
          _year = year;


          _month = month;
          _day = day;
     }
  private:
      int _year;
      int _month;
      int _day;
 };
  
  void TestDate()
 {
      Date d1; // 调用无参构造函数
      Date d2(2015, 1, 1); // 调用带参的构造函数
  
      
      // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
      // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
      Date d3();//这是一个函数声明
 }

注意：通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明

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

这个自动生成的无参的默认构造函数有什么用呢？
在这里插入图片描述

解答：
编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。
C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类
型，如：int/char…，自定义类型就是我们使用class/struct/union等自己定义的类型

#include <iostream>
using namespace std;
class Time
{
public:
     Time()
     {
         cout << "Time()" << endl;
         _hour = 0;
         _minute = 0;
         _second = 0;
     }
private:
     int _hour;
     int _minute;
     int _second;
};
class Date
{
private:
     // 基本类型(内置类型)
     int _year;
     int _month;
     int _day;
     // 自定义类型
     Time _t;
};
int main()
{
     Date d;
     return 0;
}

**注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给默认值。

class Date
{
private:
     // 基本类型(内置类型)
     int _year = 1998;
     int _month = 1;
     int _day = 1;
     // 自定义类型
     Time _t;
};

3. 析构函数（Destructor）

3.1 概念

学习了构造函数我们知道一个对象是从哪来的，那么一个对象是如何消失的呢？

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

3.2 特性

析构函数是特殊的成员函数，它有如下特点：
1️⃣析构函数名是在类名前加上字符 ~
2️⃣无参数无返回值类型
3️⃣ 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数
注意：析构函数不能重载
4️⃣对象生命周期结束时，C++编译系统系统自动调用析构函数

接下来我们用数据结构中的栈来作示例

#include <iostream>
using namespace std;
typedef int DataType;
class Stack
{
public:
     Stack(size_t capacity = 3)
     {
         _array = (DataType*)malloc(sizeof(DataType) * capacity);
         if (NULL == _array)
         {
             perror("malloc申请空间失败!!!");
             return;
         }
     _capacity = capacity;
     _size = 0;
 }
 void Push(DataType data)
 {
     // CheckCapacity();
     _array[_size] = data;
     _size++;
 }
     // 其他方法...
     ~Stack()
     {
         if (_array)
     {
     free(_array);
     _array = NULL;
     _capacity = 0;
     _size = 0;
     
private:
     DataType* _array;
     int _capacity;
     int _size;
};
void TestStack()
{
     Stack s;
     s.Push(1);
     s.Push(2);
}

5️⃣和构造函数一样，关于编译器自动生成的析构函数，会对自定类型成员调用它的析构函数

class Time
{
public:
     ~Time()
     {
         cout << "~Time()" << endl;
     }
private:
     int _hour;
     int _minute;
     int _second;
};
class Date
{
    private:
     // 基本类型(内置类型)
     int _year = 1970;
     int _month = 1;
     int _day = 1;
     // 自定义类型
     Time _t;
};
int main()
{
     Date d;
     return 0;
}
// 程序运行结束后输出：~Time()

为什么最后会调用Time_t的析构函数呢？
解答：
因为其他三个内置类型销毁时不需要内存清理，系统会自动回收。
而_t是Time类对象，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。
但是主函数中不能直接调用Time的析构函数，所以实际调用的是Data类的析构函数，即调用Data类的析构函数，在其内部再调用Time类的析构函数
结论：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数
在这里插入图片描述