多态的代价

静态继承

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

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析构函数的内容，则是因为析构函数是非虚的，有内存泄漏的风险，预防此事只需将他变成虚函数即可。