入门cpp之构造函数和析构函数_cpp中实现析构函数 c++-优快云博客

本文链接：https://blog.youkuaiyun.com/zyzyzy_mhmhmh/article/details/147795138

前言：

在cpp中，如果一个类中什么成员都没有，简称为空类，但事实上，任何类在什么都不写的情况下，编译器会默认生成6个成员函数。成为默认成员函数，这是编译器会自己生成的。

这篇文章主要介绍析构函数和构造函数。

1.构造函数：

（1）介绍：

我们简单的写一个Date类：

class Date
{
public:
    void Init(int year,int month,int day)
      {
         _year = year;
         _month = month;
         _day = day;
      }
private:
    int _year;
    int _month;
    int _day;
};

对于上面这个类，我们每次创建一个Date类型的变量，都需要调用Init函数去初始化，难免会有忘记初始的时候。cpp中有构造函数可以在变量创建时，自动将信息设置进去，这就是构造函数。

构造函数 是一个 特殊的成员函数，名字与类名相同 , 创建类类型对象时由编译器自动调用 ，以保证

每个数据成员都有一个合适的初始值，并且 在对象整个生命周期内只调用一次 。

（2）特性：

构造函数 是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任

务 并不是开空间创建对象，而是初始化对象 。

特征如下：

1.函数名与类名相同；

2.没有返回值；

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

4.构造函数可以重载。

构造函数的调用：

需要注意的是无参数的构造函数的调用：

class Date
{
   public:
   Date()
   {  
     _year = 0;
     _month = 0;
     _day = 0;
   }
   private;
    int _year;
    int _month;
    int _day;
};

在创建这样一个类之后该如何调用呢：

int main()
{
  Date d1;//正确调用方式
  Date d1();//错误调用方式
 return 0;
}

通过无参构造函数创建对象时，不需要跟括号，这样会和函数的声明混淆。

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

 class Date
 {
  public:
 /*
 // 如果用户显式定义了构造函数，编译器将不再生成
 Date(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类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函
数
 // 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再
生成
      // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
 Date d1;//初始化时需要传参
 return 0;
 }

6.C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类

型，如： int/char... ，自定义类型就是我们使用 class/struct/union 等自己定义的类型，看看

下面的程序，就会发现编译器生成默认的构造函数会对自定义类型成员 _t 调用的它的默认成员

函数。

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

经过调试，我们会发现在默认的构造函数只会对d中的自定义类型进行处理，而内置类型不做处理。

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

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

就像上述代码这样。

7.无参的构造函数和全缺省的构造函数都成为默认构造函数，并且默认构造函数只能有一个(不然调用的时候会发生冲突，混淆)。

注意：无参构造函数，全缺省构造函数，我们没写构造函数编译器默认生成的构造函数，都可以称之为默认构造函数。

2.析构函数：

（1）概念：

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由

编译器完成的。而 对象在销毁时会自动调用析构函数，完成对象中资源的清理工作 。

（2）特性：

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

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

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

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

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

简单写一个栈来举例一下析构函数的使用：

typedef int Datatype;

class stack
{
public:
  stack(int capacity = 4)
  {
    _array = (Datatype*)malloc(sizeof(Datetype)*capacity);
    if(_array == NULL)
      {
        perror("malloc fail");
      }
    _size = 0;
    _capacity = capacity;
  }

  ~stack()
  {
    free(_array);
    _array = NULL;
    _aize = 0;
    _capacity = 0;
  }

private:
  Datetype* _array;
  int size;
  int capacity;
};

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()
对于对象d，里面有三个内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可，而_t是自定义类型，所以在d销毁时，需要将_t销毁，所以要调用Time类的析构函数。但是main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式定义，则编译器会给Date生成一个默认的析构函数，目的是在其内部调用time类的析构函数。即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁，main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数。

注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数。

6.总结：如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如 Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。