多态的代价

最新推荐文章于 2024-09-14 19:55:48 发布

白八实

最新推荐文章于 2024-09-14 19:55:48 发布

阅读量159

点赞数 5

文章标签： python 开发语言

本文链接：https://blog.csdn.net/2301_79740767/article/details/136746667

版权

文章讨论了静态继承中构造函数和析构函数的执行顺序，以及在动态内存分配下，非虚析构函数可能导致内存泄漏的问题。解决方法是将析构函数设为虚函数以确保正确执行派生类的内容。

摘要由CSDN通过智能技术生成

静态继承

基类和派生类是占一块空间，派生类在实例化时，是从上往下，是先实现基类的构造函数，后实现派生类的构造函数，例如

class T
{
    public:
        T()
        {
            this.print();
        }
        virtual void print()
        {
            //T的内容
        }
};
class T2
{
    public:
        T2()
        {
            this.print();
        }
        void print() override
        {
            //T2的内容
        }
};

此时是先执行T的构造函数，因为T2还没创建，所以此时虚构函数依旧是//T的内容，而后是T2的内容，所以打印的顺序是

//T的内容

//T2的内容

析构函数

但如果是析构函数

class T
{
    public:
        ~T()
        {
            this.print();
        }
        virtual void print()
        {
            //T的内容
        }
};
class T2
{
    public:
        ~T2()
        {
            this.print();
        }
        void print() override
        {
            //T2的内容
        }
};

因为回收是从派生类开始的，当派生类执行析构函数后已经被回收，此时到基类的析构函数时，因为T2被回收，所以他只能执行T1中虚函数的内容。

但如果动态分配内存时

#include<iostream>

class T
{
public:
	~T()
	{
		this->print();
	}
	
	virtual void print()
	{
		std::cout << "class T\n";
	}
};
class T2 :public T
{
public:
	~T2()
	{
		this->print();
	}
	
	void print() override
	{
		std::cout << "class T2\n";
	}
};
int main()
{
	T* t2 = new T2();
	t2->print();
}

就会出现析构时只调用T析构函数的内容，则是因为析构函数是非虚的，有内存泄漏的风险，预防此事只需将他变成虚函数即可。