【哇! C++】类和对象（三） - 构造函数和析构函数

        

目录

一、构造函数

1.1 构造函数的引入

1.2 构造函数的定义和语法

1.2.1 无参构造函数：

1.2.2 带参构造函数

1.3 构造函数的特性

1.4 默认构造函数

二、析构函数

2.1 析构函数的概念

2.2 特性

---

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

        空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

        默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

class Date
{};

一、构造函数

1.1 构造函数的引入

        对于Date类，有如下程序：

#include<iostream>
using namespace std;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;
};int main()
{Date d1;d1.Init(2025, 3, 5)return 0;
}

         对于Date类，可以通过Init公有方法给对象设置日期。但有时也会出现忘记Init初始化函数，而直接Push。为避免忘记，也为了方便程序撰写，所以，C++规定了构造函数。

1.2 构造函数的定义和语法

        构造函数是一种特殊的成员函数。虽然叫构造，但是其任务不是开空间，而是初始化对象。其特征如下：

1. 构造函数名与类名相同；
2. 无返回值，不需要写void，void是空返回值；
3. 对象实例化时编译器自动调用对应的构造函数；
4. 构造函数可以重载。

所以Date类构造函数可写为：

1.2.1 无参构造函数：

#include<iostream>
using namespace std;class Date
{
public:    Date(){_year = 1;_month = 1;_day = 1;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};int main()
{Date d1;d1.Print();//Date d2();//err//Date d1(2024, 1, 27);//err，没有与参数列表匹配的构造函数实例return 0;
}

运行结果为： 

        此外，C++规定，无参构造函数变量名后不能加小括号。Date d2();有可能是函数的声明，返回类型是Date，因为这个地方要写函数声明的话，小括号中是要加参数类型的。

1.2.2 带参构造函数

#include<iostream>
using namespace std;class Date
{
public:Date(){_year = 1;_month = 1;_day = 1;}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 d1(2025, 3, 5);return 0;
}

        构造函数可以函数重载，也可以改写为全缺省。

#include<iostream>
using namespace std;class Date
{
public:Date(){_year = 1;_month = 1;_day = 1;}Date(int year = 1, int month = 1, int day = 1){_year = year;_month = month;_day = day;}void Print{cout << _year << "-" << _month << "-" << _day << endl;}private:int _year;int _month;int _day;
};int main()
{Date d1;Date d2(2025, 3, 5);return 0;
}

        语法上，上述两个函数也可以同时存在，因为函数重载，函数名虽然相同，但参数不同。但是在调用Date d1;时，会产生歧义，编译器不知道要调用谁，是要调用无参的还是要调用全缺省的。所以一般情况下，我们不这样写。

1.3 构造函数的特性

        1.C++规定，对象定义（实例化）的时候，必须调用构造函数。

        2.构造函数是默认成员函数，默认成员函数的特征是：我们没有显示定义，编译器会自动生成一个无参的；如果写了，编译器就不会生成。

        但是，当我们这样写如下代码以后，编译器调用了默认生成的构造函数，但是什么也没干，没有初始化。

#include<iostream>
using namespace std;class Date
{
public:void func(){cout << _year << "-" << _month << "-" << _day << endl;}private:int _year = 1;int _month = 1;int _day;
};int main()
{Date d1;d1.Print();//A _aa;return 0;
}

运行过程为：

运行结果为：

        说明了使用编译器实现的默认构造函数出来初始化的数据是随机值，不是0。

        C++98规定，默认生成的构造函数，对于内置类型不做处理；对于自定义类型会直接调用他的默认构造函数。即编译器对生成默认了构造函数，对int不做处理，但对于自定义成员类型A aa；要调用A的构造函数。

        内置类型/基本类型       -       int/char/double/指针

        自定义类型                   -       struct/class

        C++11对这个语法进行补丁，在声明的位置给缺省值。即不给缺省值，编译器什么都不管；给缺省值，就默认生成了构造函数，用缺省值去完成初始化。在类中，默认了Date(){int _year = 1;int _month = 1;};

1.4 默认构造函数

#include<iostream>
using namespace std;class Date
{    
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year = 1;int _month = 1;int _day;
};int main()
{Date d1;return 0;
}

        当我们运行时发现上述代码报错：此处编译报错，提示没有默认构造函数可以用。

        很多人经常理解默认构造函数就是编译器生成的那一个。编译器默认生成的构造函数是默认构造函数，但只是其中之一。

        无参的构造函数和全缺省构造函数也被称为默认构造函数，且默认构造函数有且只能有一个。 一般情况下，建议优选全缺省构造函数。

总结：不需要传参就可以调用的构造函数，都可以叫默认构造函数。

        所以，上述代码中，没有无参，也没有全缺省的默认构造函数，此时就需要编译器就要生成一个默认构造函数。

        但是编译器默认生成的构造函数是有条件的，基于默认成员函数的特性：即没有写显示定义的构造函数，编译器才会自动生成一个无参的默认构造函数；一旦用户显示定义，编译器就不会再生成。

        为了使上述程序能够通过，需要函数重载，显式定义一个默认构造函数。

#include<iostream>
using namespace std;class Date
{    
public:Date(){_year = 1;_month = 1;_day = 1;}Date(int year, int month, int day){_year = year;_month = month;_day = day;}Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:int _year = 1;int _month = 1;int _day;
};int main()
{Date d1;return 0;
}

二、析构函数

2.1 析构函数的概念

        内存泄漏是不会报错的，所以经常会忘记destory，所以C++就有了析构函数。

        析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。相当于destory，把动态开辟的数组空间free掉，不清理的话会出现内存泄漏。所以：构造函数完成的不是创建，析构函数完成的也不是销毁。

        在函数名前加~，在C语言中，~表示按位取反，所以选用这个符号就表示和构造函数的功能是相反的。

2.2 特性

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

1. 析构函数名是类名前加字符“~”；
2. 没有参数也没有返回值；
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载；
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

        第4点类似于构造函数，构造函数在实例化的时候会自动调用。

#include<iostream>
using namespace std;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()。

        在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？

        因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year，_month，_day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。

        但是：main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数。

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

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

#include<iostream>
using namespace std;class Stack
{
public:    Stack(int capacity = 3){cout << "Stack(int capacity = 3)" << endl;_arry = (int*)malloc(capacity * sizeof(4));if(_arry == NULL){perror("malloc");}_capacity = capacity;}void Push(int x){_arry[_size] = x;_size++;}~Stack(){cout << "~Stack()" << endl;free(_arry);_arry = NULL;_size = 0;_capacity = 0;}private:int* _arry;int _capacity = 0;int _size = 0;
};//注意必须要有分号class MyQueue
{
private:Stack st1;Stack st2;int _size = 0;
};//注意必须要有分号int main()
{MyQueue q;return 0;
}

运行结果为： 

2.3 析构顺序        

        销毁顺序为：局部对象（后定义的先析构）->局部的静态->全局对象（后定义的先析构）。程序证明如下：

class Date
{
public:Date(int year = 1){_year = year;}~Date(){cout << "~Date()->" << _year << endl;}
private:int _year ;int _month;int _day;
};void func()
{Date d3(3);static Date d4(4);
}Date d5(5);
static Date d6(6);int main()
{Date d1(1);Date d2(2);func();return 0;
}

        static Date d3(3);为局部静态，和上边两个的存储区域不同，第3是存在静态区的，虽然定义在了局部，但是生命周期是全局的。在main函数结束以后才会销毁。所以在这之前要先把main函数中的局部变量先销毁。