构造函数与析构函数的显示调用

小呆瓜历险记

于 2024-03-27 17:20:04 发布

阅读量958

点赞数 19

文章标签：开发语言 c++

本文链接：https://blog.csdn.net/m0_58963318/article/details/137075435

版权

前言：

构造函数是类的特殊成员函数，创建对象时编译器会自动调用构造函数；

析构函数是类的特殊成员函数，当对象的生命周期结束时，编译器自动隐式调用析构函数；

构造函数的显示调用

构造函数按照参数类型可以分为有参构造与无参构造，调用构造函数的方式分别为显示调用与隐式调用；

显示调用无参构造

class Date
{
public:
	//构造函数函数名与类名相同且无返回值
	//无参构造
	Date()
	{
		cout << "调用构造函数" << endl;
	}
private:
	int _year = 2024;
	int _month = 3;
	int _day = 1;
};
int main()
{
	//显示调用
	Date d = Date();
	return 0;
}

监视窗口：

运行窗口：

注：构造函数调用时先执行初始化列表的位置，在执行函数体中的语句；

隐式调用无参构造

class Date
{
public:
	//构造函数函数名与类名相同且无返回值
	//无参构造
	Date()
	{
		cout << "调用构造函数" << endl;
	}
private:
	int _year = 2024;
	int _month = 3;
	int _day = 1;
};
int main()
{
	//隐式调用
	Date d;
	return 0;
}

监视窗口：

运行窗口：

显示调用有参构造

class Date
{
public:
	//构造函数函数名与类名相同且无返回值
	//有参构造
	Date(int year,int month,int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{
		cout << "调用构造函数" << endl;
	}
private:
	int _year = 2024;
	int _month = 3;
	int _day = 1;
};
int main()
{
	//显式调用
	Date d(2024, 3, 15);
	return 0;
}

监视窗口：

运行窗口：

总结：

一般情况下默认的无参构造函数是自动地隐式调用；
有参构造函数是由开发者手动地显示调用；

构造函数的执行顺序

class A
{
public:
	A()
	{
		cout << "调用A类的构造函数" << endl;
	}
private:
	int _a = 1;
};

class B
{
public:
	B()
	{
		cout << "调用B类的构造函数" << endl;
	}
private:
	int _b = 2;
};

class C
{
public:
	C()
	{
		cout << "调用C类的构造函数" << endl;
	}
private:
	int _c = 3;
};

class D
{
public:
	D()
	{
		cout << "调用D类的构造函数" << endl;
	}
private:
	int _d = 4;
};

C c;//全局对象
int main()
{
	A a;
	B b;
	static D d;//静态对象
	return 0;
}

运行结果：

构造函数：定义对象时进行调用；

析构函数的显示调用

析构函数的调用顺序

class A
{
public:
	~A()
	{
		cout << "调用A类的析构函数" << endl;
	}
private:
	int _a = 1;
};

class B
{
public:
	~B()
	{
		cout << "调用B类的析构函数" << endl;
	}
private:
	int _b = 2;
};

class C
{
public:
	~C()
	{
		cout << "调用C类的析构函数" << endl;
	}
private:
	int _c = 3;
};
class D
{
public:
	~D()
	{
		cout << "调用D类的析构函数" << endl;
	}
private:
	int _d = 4;
};

C c;//全局对象
int main()
{
	A a;//局部对象
	B b;//局部对象
	static D d;//静态对象
	return 0;
}

运行结果：

监视窗口：

局部对象的析构顺序与构造顺序相反，由于局部对象存放于栈区，栈区高地址处存放对象a,低地址处存放对象b（栈区使用习惯先使用高地址，再使用低地址），析构时先销毁低地址处的局部对象，后销毁高地址处的局部对象；
static修饰的静态对象存放于静态区，对象生存的作用域（main()函数内部）结束时销毁；
程序结束时销毁全局对象；

显示调用析构函数

class Test
{
public:
	Test()
	{
		cout << "调用构造函数" << endl;
	}
	~Test()
	{
		cout << "调用析构函数" << endl;
	}
private:
	int _a;
};

int main()
{
	Test t;
	t.~Test();//显示调用析构函数
	return 0;
}

运行结果：

开发者创建的对象通常在语句体{ }中，当语句体{ }结束时该对象被销毁，但是这种对象通常存放于栈区这就意味着如何管理此对象，是由操作系统完成而开发者无法控制；所以即使开发者显示调用析构函数，当对象的生命周期结束时，操作系统依然会再次调用析构函数，将其在栈区销毁，实现真正的析构；

class Test
{
public:
	Test()
	{
		cout << "调用构造函数" << endl;
		_a = new int[10];//堆区申请空间
	}
	~Test()
	{
		cout << "调用析构函数" << endl;
		delete[] _a;//释放堆区开辟的空间
	}
private:
	int* _a;
};

int main()
{
	Test t;
	t.~Test();
	return 0;
}

运行结果：

一旦析构函数中存在释放堆空间的语句，第二次调用析构函数会释放已经释放的空间，导致系统崩溃；

第一次显示调用析构函数，相当于调用一个普通的成员函数，执行函数体内的语句，释放了堆内存，但是并未释放栈内存，对象还存在；

第二次操作系统调用析构函数，再次释放堆内存，造成系统崩溃，然后真正释放栈内存，销毁对象；