析构函数详解

感谢各位大佬对我的支持,如果我的文章对你有用,欢迎点击以下链接
🐒🐒🐒 个人主页
🥸🥸🥸 C语言
🐿️🐿️🐿️ C语言例题
🐣🐣🐣 python
🐓🐓🐓 数据结构C语言
🐔🐔🐔 C++
🐿️🐿️🐿️ 文章链接目录

析构函数

概念

通过上一篇文章我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？

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

而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作(有点像数据结构中的Destroy函数,作用就是清理链表 树 或堆上的空间清理,如果不清理会出现内存泄漏的情况)

注意对象空间的开辟和销毁不需要我们去解决,这些都是由系统去完成的(全局 对象 静态都是系统自己去解决),而像堆上的空间就需要我们去完成了,比如malloc开辟空间的时候需要我们去完成,在最后释放的时候也是需要我们自己去free掉空间

特性

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

1. 析构函数名是在类名前加上字符 ~
2. 无参数无返回值类型。
   具体结构如下:

class Date
{
	~Date()
	{
		;
	}
};

类名前的~在C语言中表示按位与取反,这里的取反有完全相反的意思,所以 ~放在析构函数这里就是想说明析构函数的作用和构造函数是完全不同的

特别注意析构函数是没有参数的,而构造函数是有参数的,因为构造函数要构造,传参可以初始化,而析构函数完全没必要传参,所以就没有参数

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

class Date
{
public:
	Date()
	{
		_year = 1;
		
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
};
int main()
{
	Date d1;

	return 0;
}

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

5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数。

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

由于析构函数和构造函数都是特殊的类,所以都是有this指针的

class Date
{
public:
	Date()
	{
		_year = 1;
		
	}
	~Date()
	{
		cout << this << endl;
		cout << "~Date()" << endl;
	}
	void Print()
	{
		cout << this << endl;
		cout << "Print()" << endl;
	}
private:
	int _year;
};
void func()
{
	Date d2;
}
int main()
{
	func();
	Date d1;
	d1.Print();
	return 0;
}

通过调试我们可以看到,d1和d2的地址以this指针的方式传给函数,d1和d2在生命周期结束时会调用析构函数,而析构函数里面是打印this指针

我们来看看下面的代码来具体理解析构函数

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;
};
int main()
{
	Stack s;
	s.Push(1);
	s.Push(2);
}

在C语言中当没有调用Destroy函数会发生内存泄漏,具体过程如下

main函数会在栈上开辟一块空间,这块空间中也包含Stack s的指针DataType* _array(只是这个指针在mian函数开辟的空间里)

DataType* _array中_arrray的作用是保存Stack s开辟空间的地址
在main函数执行完后,会将main函数在栈上开辟的空间都销毁,其中就包括了指针_array
由于_array是保存着Stack s开辟空间的地址,最终会因为指针_array被销毁,导致找不到Stack s开辟出的空间

所以没调用Destroy函数发生的后果是很严重的,并且我们经常会忘记调用Destroy函数,为了解决这个问题才有了析构函数,因为析构函数自动调用,并且编译器可以自动生成析构函数,这对我们来说是非常方便的

但是需要注意的是默认生成的析构函数和默认生成的构造函数类似,对内置类型不做处理,自定义类型的成员会去调用他的析构函数

对象的销毁顺序

生命周期对于现在学到的来说有两种,一种是局部(存在一些函数中,因为调用函数会开辟栈帧,所以函数结束后栈帧也会被销毁,函数中的局部变量也就销毁了),另一种是静态或者全局的(存在静态区里,在mian函数结束后就会销毁)

而对象生命周期结束时，C++编译系统系统自动调用析构函数,那如果有多个对象生命周期同时结束,系统会优先给谁调用析构函数

class Date
{
public:
	Date(int year)
	{
		_year = year;
}
	~Date()
	{
		cout << "~Date()" << _year<<endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(1);
	Date d2(2);
}

这段代码中我们只定义了一个成员变量_year,其他的_month以及_day都只是声明,不占用内存空间,mian函数中Date d1(1),Date d2(2)是对_year进行初始化,在函数结束后两个对象的生命周期都会结束,而销毁的顺序如图

这个调用的顺序像栈中的后进先出,Date d1先入栈,所以最后调用析构函数,事实上对象确实存储在栈上的,因为类其实是一个函数,在函数调用时会建立栈帧,所以空间存储在栈上

class Date
{
public:
	Date(int year)
	{
		_year = year;
}
	~Date()
	{
		cout << "~Date()" << _year<<endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(1);
	Date d2(2);
	static Date d3(3);
}

那如果让Date d3加上一个static去修饰结果会怎么样

加上static修饰后Date d3的存储区域就发生变化了,d3存储在一个单独的静态区中,虽然d3是一个局部变量,但是他的生命周期在经过static修饰后变成全局,所以d3会在main函数结束后销毁,而在main函数结束前会将里面的d1和d2等局部变量先销毁掉,所以d3排在最后

我们再来看看下面的代码,这段代码中定义了一个函数func,将类的对象定义在函数中,其中d4是被static修饰的,而d3没有被修饰,然后在main函数中调用func

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

销毁顺序是3 2 1 4,具体原因还是因为func也是一个函数,空间开辟在栈上的,满足后进先出原则,所以先销毁对象d3(对于d3为什么是最先销毁,可能是因为他在函数func中,算是一个局部中的局部吧),然后又是d2 d1,d4因为被static修饰,所以最后销毁

我们再在main函数外定义一个对象d5又会怎么样

class Date
{
public:
	Date(int year)
	{
		_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);
int main()
{
	Date d1(1);
	Date d2(2);
	func();
}

结果是3 2 1 4 5

d5虽然没有被static修饰,但是他定义在main函数外的,所以他自己就是一个全局变量,但是这里的全局变量有两个,一个是d4,一个是d5,他们的销毁顺序是否也和自己的位置有关呢?

我们将d5的定义移到func函数上边,发现没有变化,所以推测可能是因为d4是在func函数中,所以相对于d5来讲,d4的声明周期是局部的

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

我们再在main函数外定义一个d6,用static修饰他的顺序又会怎么样

当d6和d5交换顺序后,发现销毁的顺序变化了,所以我们得出结论,全局的销毁顺序和局部的销毁顺序也是一样的,当d5后入栈时,d5就先销毁,而static修饰全局变量d6,并不会改变d6的销毁顺序


如果在多个函数func中定义类的顺序会怎么样

class Date
{
public:
	Date(int year)
	{
		_year = year;
}
	~Date()
	{
		cout << "~Date()" << _year<<endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
static Date d6(6);
Date d5(5);
void func2()
{
	Date d7(7);
	static Date d8(8);
}
void func1()
{
	Date d3(3);
	static Date d4(4);
}

int main()
{
	Date d1(1);
	Date d2(2);
	func1();
	func2();
}

这里说下我的想法,func1和func2因为都是在栈上开的空间,所以他们的销毁的顺序满足后进先出,具体判断谁先销毁的方法就是看谁最先被调用,也就是在main函数中去看func1是否比func2先调用,如果先比func2调用,那就说明func1先开辟空间,所以func1要比func2后销毁

最终顺序总结如下
局部对象(后定义先析构)->局部静态->全局对象(后定义先析构)

类中没有显示定义析构函数,系统则会自动生成默认的析构函数,那这个析构函数是否和构造函数一样基本上什么事都不做呢?
由于自定义类型的尽头是内置类型,对应类而言如果类中没有申请资源时，析构函数可以不写(因为不写不会有影响),有资源申请时，一定要写，否则会造成资源泄漏

为什么析构不可以自己去处理内置类型呢?
因为内置类型中有指针等许多不能随便处理的类型,假如指针指向了一块空间,如果析构函数可以处理内置类型的话,有可能会直接把指针指向的空间给销毁了,这样指针就变成了野指针