写在前面
构造函数与析构函数都是属于类的默认成员函数！
默认成员函数是程序猿不显示声明定义，编译器会中生成。
构造函数和析构函数的知识需要建立在有初步类与对象的基础之上的，关于类与对象不才在前面笔记中有详细的介绍：点我跳转
文章目录
- 写在前面
- 一、构造函数的特性
- 1.1、函数名与类名相同。
- 1.2、 无返回值。
- 1.3、 对象实例化时编译器自动调用对应的构造函数。
- 1.4、构造函数可以重载。
- 1.5、如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
- 1.6、无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
- 1.7、构造函数的初始化列表
- 二、析构函数
- 2.1、析构函数名是在类名前加上字符 ~
- 2.2、无参数无返回值类型
- 2.3、一个类只能有一个析构函数。
- 2.4、对象生命周期结束时，C++编译系统系统自动调用析构函数。
- 2.5、编译器生成的默认析构函数，对自定类型成员调用它的析构函数
- 2.6、如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数
一、构造函数的特性
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象
其特征如下：
1.1、函数名与类名相同。
1.2、 无返回值。
1.3、 对象实例化时编译器自动调用对应的构造函数。
class stack {
public:
stack() {//构造函数
cout << "this is stack()" << endl;
}
void Init(int defintCapacity) {
_arr = (int*)calloc(defintCapacity, sizeof(int));
if (nullptr == _arr)
{
perror("malloc申请空间失败");
return;
}
_capacity = defintCapacity;
_size = 0;
}
void push(int x) {
//....扩容等
_arr[_size++] = x;
}
private:
int* _arr;
int _size;
int _capacity;
};
int main() {
stack s1;
return 0;
}
程序运行结果：
- 在上述代码中，不才创建了一个默认构造函数
stack，在构造函数中，我们只让其打印字符串this is stack()，之后，我们在s1对象中，并没有显示的调用构造函数，但是字符串就被打印出来了，这就说明的对象实例化时编译器自动调用对应的构造函数
这时候，我们就可以把stack的初始化函数设置放入构造函数中，每当我们创建一个对象时，通过构造函数自动初始化数据。如下：
class stack {
public:
stack(int defintCapacity = 4) {
_arr = (int*)calloc(defintCapacity, sizeof(int));
if (nullptr == _arr)
{
perror("malloc申请空间失败");
return;
}
_capacity = defintCapacity;
_size = 0;
}
void push(int x) {
//....扩容等
_arr[_size++] = x;
}
private:
int* _arr;
int _size;
int _capacity;
};
int main() {
stack s1;
return 0;
}
运行结果：
- 这时候，我们就不用每次都显示的初始化数据了，而且也不怕忘记初始化。
1.4、构造函数可以重载。
构造函数也是函数，是函数就可以重载
class stack {
public:
stack(int defintCapacity = 4) {
_arr = (int*)calloc(defintCapacity, sizeof(int));
if (nullptr == _arr)
{
perror("malloc申请空间失败");
return;
}
_capacity = defintCapacity;
_size = 0;
}
stack(int* arr, int defintCapacity) {
if (nullptr == arr) {
perror("malloc申请空间失败");
return;
}
_arr = arr;
_capacity = defintCapacity;
_size = 0;
}
void push(int x) {
//....扩容等
_arr[_size++] = x;
}
private:
int* _arr;
int _size;
int _capacity;
};
int main() {
int* arr = (int*)calloc(2, sizeof(int));
stack s1(arr, 2);
return 0;
}
程序运行结果：
和函数重载一样的逻辑，编译器会根据符号名去调用对应的构造函数。
需要注意，调用默认构造函数不需要加括号，因为加上括号后，编译器会认为是函数
举个栗子：
stack s1：这时s1代表的是调用stack的默认构造函数的对象
stack s1()：这时s1就被当做，返回值是stack类且没有形参的函数。
有参调用就和普通函数一样，只不过是对象+参数列表stack s1(arr, 2)
1.5、如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
默认构造函数在C++中有特殊定义，在C++标准中，默认构造函数不会对内置类型进行处理，自定义类型会调用它的默认构造函数。但是现在有些编译器会对内置类型进行初始化，但这是该编译器自己的行为，C++标准中是不进行处理的。
内置类型/基本类型：语言本身定义的基础类型(如int、char、指针、double等)
自定义类型：使用class、struct等定义的类型
class stack {
public:
stack(int defintCapacity = 4) {
_arr = (int*)calloc(defintCapacity, sizeof(int));
if (nullptr == _arr)
{
perror("malloc申请空间失败");
return;
}
_capacity = defintCapacity;
_size = 0;
}
stack(int* arr, int defintCapacity) {
if (nullptr == arr) {
perror("malloc申请空间失败");
return;
}
_arr = arr;
_capacity = defintCapacity;
_size = 0;
}
void push(int x) {
//....扩容等
_arr[_size++] = x;
}
private:
int* _arr;
int _size;
int _capacity;
};
class Date
{
public:
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main() {
Date d1;
return 0;
}
程序运行结果：(在vs2022环境下)
在默认构造函数中，并不会对定义类型进行任何操作，貌似不能证明默认构造函数的存在，但是我们把Date类设置为，下程序时：
class stack {
public:
stack(int defintCapacity = 4) {
_arr = (int*)calloc(defintCapacity, sizeof(int));
if (nullptr == _arr)
{
perror("malloc申请空间失败");
return;
}
_capacity = defintCapacity;
_size = 0;
}
stack(int* arr, int defintCapacity) {
if (nullptr == arr) {
perror("malloc申请空间失败");
return;
}
_arr = arr;
_capacity = defintCapacity;
_size = 0;
}
void push(int x) {
//....扩容等
_arr[_size++] = x;
}
private:
int* _arr;
int _size;
int _capacity;
};
class Date
{
public:
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
//内置类型
int _year;
int _month;
int _day;
//自定义类型
stack _st;
};
int main() {
Date d1;
return 0;
}
运行结果：(在VS2013编译器中)
- 在vs2013中，我们可以清晰看出内置类型是不会进行处理的，而自定义类型是会调用其默认构造函数
但是我们在VS2022中尝试一下
- 我们发现在vs2022编译环境下，有自定义类型情况中，内置类型会被初始化为0，在上例中，我们也发现，在没有自定义类型情况中，内置类型是不会处理的
所以，不才推荐在C++中类中，我们默认内置类型是未被处理的，自定义类型是会调用其默认构造函数的，这样不会出现程序运行错误。
在
C++11后，对成员变量做了一个补丁，可以在声明成员变量时给定一个缺省值。
这里不才以内置类型为例，
class Date
{
public:
Date(){}
Date(int year, int month, int day) {
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
//内置类型
//这里不是初始化，而是声明
//这里给的是默认缺省值，给编译器生成默认构造函数时使用
int _year = 1;
int _month = 1;
int _day = 1;
};
int main() {
Date d1;
d1.Print();
return 0;
}
程序运行结果：
如果我们调用默认构造函数，那么内置类型的值就是程序猿给定的缺省值。如果我们调用不是默认构造函数，那么使用的就是自定义构造函数的值，如下图。
什么情况下可以直接使用默认构造函数：
- 内置类型成员都有缺省值，且初始化符合要求
- 全部都是自定义类型成员，且这些类型都定义了默认构造函数。
1.6、无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
虽然在语法中，无参的构造函数和全缺省的构造函数形参了函数重载，编译不会有错，但是在对象初始化时，无参调用存在歧义。
class Date
{
public:
Date() {}
Date(int year = 2035, int month = 1, int day = 1) {
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year = 1;
int _month = 1;
int _day = 1;
};
int main() {
Date d1;
d1.Print();
return 0;
}
程序运行结果：
- 无参构造函数和全缺省的构造函数都是不需要传参调用的，所以在函数调用时，就会报错
对重载函数的调用不明确
无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，只要不传参就可以调用的，都可以认为是默认构造函数，而默认构造函数只能存在一个！
1.7、构造函数的初始化列表
构造函数体赋值
在上述的构造器中，我们构造函数内进行的操作是构造函数体赋值，这些操作只是赋值，并不是属性的初始化定义。如下
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
_year = year;、_month = month;、_day = day;这些在构造器中只是充当赋值的作用，并不是对属性_year、_month、_day的初始化定义。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
初始化列表：把类中的所有属性进行初始化定义。
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个 “成员变量” 后面跟一个放在括号中的初始值或表达式。如下代码
class Date
{
public:
Date(int year, int month, int day)
:_year(year)
,_month(month)
,_day(day)
//，_day(day) err：最多只能出现一次
{
}
private:
int _year;
int _month;
int _day;
};
- 每个成员变量在初始化列表中最多只能出现一次(初始化只能初始化一次)
- 类中包含以下成员，必须放在初始化列表位置进行初始化：
- 引用成员变量
const成员变量- 自定义类型成员(且该类没有默认构造函数时)
因为引用成员变量和 const成员变量在初始化时，必须要进行赋值。而自定义类型成员。构造函数编译器只会调用自定义类型的默认构造函数，如果没有默认构造函数的情况编译器就无法找到自定义类型所对应的构造函数。
引用成员变量和 const成员变量 不在初始化列表进行初始化。而在构造函数体赋值中进行赋值来达到初始化。
自定义类型在没有默认构造函数的情况下，让编译器自己去寻找默认构造函数。
所以我们就必须在属性初始化的时候赋初值。如下代码：
class A {
public:
A(int a)
:_a(a)
{ }
private:
int _a = 0;
};
class Date
{
public:
Date(int year, int month, int day)
:_year(year)
,_month(month)
,aa(10)
{
}
private:
A aa;
const int _year;
int& _month;
int _day;
};
尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。 对于内置类型也是在初始化列表中进行初始化。
我们属性都是在初始化列表中进行初始化。构造函数体赋值一般是完成初始化列表不能完成的工作。如检查动态开辟内存是否为空等操作。
class stack {
public:
stack(int size)
:_arr( (int*)malloc(sizeof(int) * size) )
,_capacity(0)
,_size(size)
{
//检查_arr动态开辟的空间是否为空
if (_arr == nullptr) {
perror("malloc::>");
exit(1);
}
//再把_arr初始化为0
memset(_arr, 0, (sizeof(int) * size) );
}
private:
int* _arr;
int _capacity;
int _size;
};
int main() {
stack s1(10);
return 0;
}
成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
在上述的stack类中，很多小伙伴在动态开辟_arr的初始化时，先在初始化列表时把_size放在了_arr的前面，之后把_arr计算空间大小的size使用了属性的_size这样导致的程序崩溃
class stack {
public:
stack(int size)
: _capacity(0)
, _size(size)
,_arr( (int*)malloc(sizeof(int) * _size) )
{
//检查_arr动态开辟的空间是否为空
if (_arr == nullptr) {
perror("malloc::>");
exit(1);
}
//再把_arr初始化为0
memset(_arr, 0, (sizeof(int) * size) );
}
private:
int* _arr;
int _capacity;
int _size;
};
int main() {
stack s1(10);
return 0;
}
- 这时候初始化顺序是先初始化
_arr数组，此时_size并没有被初始化，那么这时候_size就是一个随机值。 - 我们使用一个巨大的随机值去动态开辟一个空间，那么动态开辟出来的空间也是一个巨大的空间，所以程序会崩溃。
- 只有初始化完了
_arr数组，再初始化_capacity，最后初始化_size。
为了深刻理解：我们再举个栗子，下面程序运行结果是什么。
class A
{
public:
A(int a)
:_a1(a)
, _a2(_a1)
{}
void Print() {
cout << _a1 << " " << _a2 << endl;
}
private:
int _a2;
int _a1;
};
int main() {
A aa(20);
aa.Print();
}
- 根据我们理解的：成员变量在类中声明次序就是其在初始化列表中的初始化顺序，此时程序的运行结果为：
20随机值
不才这里建议：声明的顺序与初始化列表顺序保持一致
二、析构函数
析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。
析构函数是特殊的成员函数，其特征如下：
2.1、析构函数名是在类名前加上字符 ~
2.2、无参数无返回值类型
2.3、一个类只能有一个析构函数。
若未显式定义，系统会自动生成默认的析构函数。注意：析构函数没有形参所以不能重载
2.4、对象生命周期结束时，C++编译系统系统自动调用析构函数。
class Date
{
public:
Date() {
cout << "Date()" << endl;
}
Date(int year, int month, int day) {
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
~Date() {
cout << "~Date()" << endl;
}
private:
int _year = 1;
int _month = 1;
int _day = 1;
};
int main() {
Date d1;
{//创建了代码块用于验证：对象生命周期结束时，C++编译系统系统是否会自动调用析构函数
Date d2;
d2.Print();
printf("\n");
cout << &d2 << endl;
}
printf("\n");
d1.Print();
return 0;
}
程序运行结果：
2.5、编译器生成的默认析构函数，对自定类型成员调用它的析构函数
class stack {
public:
stack(int defintCapacity = 4) {
_arr = (int*)calloc(defintCapacity, sizeof(int));
if (nullptr == _arr)
{
perror("malloc申请空间失败");
return;
}
_capacity = defintCapacity;
_size = 0;
cout << "stack()" << endl;
}
stack(int* arr, int defintCapacity) {
if (nullptr == arr) {
perror("malloc申请空间失败");
return;
}
_arr = arr;
_capacity = defintCapacity;
_size = 0;
}
void push(int x) {
//....扩容等
_arr[_size++] = x;
}
~stack() {
free(_arr);
_arr = nullptr;
cout << "~stack()" << endl;
}
private:
int* _arr;
int _size;
int _capacity;
};
class Date
{
public:
Date() {
cout << "Date()" << endl;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
//内置类型 给定缺省值
int _year = 1;
int _month = 1;
int _day = 1;
//自定义类型
stack _st;
};
int main() {
Date d1;
d1.Print();
return 0;
}
程序运行结果：
main方法中创建了Date对象d1，而d1中包含4个成员变量，其中_year,_month,_day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可。- 但是
_st是stack类的对象，所以在d1销毁时，要将其内部包含的stack类的_st对象销毁，所以要调用stack类的析构函数。 main函数中不能直接调用stack类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用stack类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁
2.6、如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数
析构函数的使用：
- 一般情况下，有动态申请资源 ，就需要显示写析构函数释放资源
- 没有动态申请资源，不需要写析构函数
- 需要释放资源的类型都是自定义类型，在该类中就不需要写析构函数。因为默认生成的析构函数遇到自定义类型会自动调用自定义类型的析构函数
- 特殊场景特殊使用
以上就是本章所有内容。若有勘误请私信不才。万分感激💖💖 如果对大家有用的话，就请多多为我点赞收藏吧~~~💖💖
ps:表情包来自网络，侵删🌹
![[c语言日寄]（bit）位检查——初探字节之下](https://i-blog.csdnimg.cn/direct/95b30a39409141ce8831734cb6221d47.png)
