虚析构和纯虚析构

前言： 当使用父类指针指向子类对象，delete指针时，只会调用父类的析构函数，而不会调用子类的析构函数。这就存在子类对象没被释放的问题，导致内存泄漏

• 父类上使用虚析构和纯虚析构都能解决上面的问题，但是需要注意：纯虚析构也要有具体实现；且如果包含了纯析构函数，则变成了一个抽象类。
• 形式：virtual ~父类名() {}

//虚析构和纯虚析构
//场景：当使用父类指针指向子类对象，delete指针时，只会调用父类的析构函数，而不会调用子类的析构函数。这就存在子类对象没被释放的问题，导致内存泄漏
//父类上使用虚析构和纯虚析构都能解决上面的问题，但是需要注意：纯虚析构也要有具体实现；且如果包含了纯析构函数，则变成了一个抽象类。
//形式：virtual ~父类名() {}
class Base
{
public:
	virtual void function() = 0;
	Base()
	{
		cout << "Base构造函数\n";
	}
	//虚析构
	virtual ~Base()
	{
		cout << "Base析构函数\n";
	}
};
class Son : public Base
{
public:
	//属性创建在堆上
	int* p_age;
	void function()
	{
		cout << "Son is working " << *p_age << endl;
	}
	Son(int age)
	{
		p_age = new int(age);
		cout << "Son构造函数\n";
	}
	~Son()
	{
		if (p_age != NULL)
		{
			delete p_age;
			p_age = NULL;
		}
		cout << "Son析构函数\n";
	}
};
void test()
{
	Base* b = new Son(20);
	b->function();
	delete b;
}
int main()
{
	test();
	return 0;
}

在C++中，多态性的实现和联编（也称绑定）这一概念有关。一个源程序经过编译、链接，成为可执行文件的过程是把可执行代码联编（或称装配）在一起的过程。其中在运行之前就完成的联编成为静态联编（前期联编）；而在程序运行之时才完成的联编叫动态联编（后期联编）。

静态联编支持的多态性称为编译时多态性（静态多态性）。在C++中，编译时多态性是通过函数重载和模板实现的。利用函数重载机制，在调用同名函数时，编译系统会根据实参的具体情况确定索要调用的是哪个函数。

动态联编所支持的多态性称为运行时多态（动态多态）。在C++中，运行时多态性是通过虚函数来实现的。

一个动态联编的例子：
场景：码农小A为银行后天做开发，需要设计两个类，一个是没有透支的类，一个是透支的类，两个类都有一个展示数据的功能show，但透支的类会展示透支的数据。会计大妈业务繁忙，需要可以查看上万人的账户情况，想让会计通过小A开发的软件简便去查看数据，只需要输入1查看没有透支的账户，输入2查看透支的账户。
解决：因为透支类成员包含未透支类的成员，且有额外的透支金额等成员，故透支类继承未透支的类，将show在基类中声明为虚，在各自类中定义其功能。定义一个指向基类的指针数组同时管理未透支的类和透支的类，其中每个指针指向一个账户。
用for循环遍历整个指针数组，当会计大妈输入1时将当前指针指向未透支的类，输入2时指向透支的类，每次输入后根据指向的对象类型立即调用对应的show函数。
分析：程序运行前编译器不知道指针指向什么类型的成员，即不知道会计大妈想看透支的类还是未透支的类。因此编译器在程序运行时根据用户的输入选择正确的虚方法，这就是动态联编。
评价：动态联编虽然给予了更多的灵活性，但相较于静态联编增加了额外的开销，因此只将那些预期被重新定义的方法声明为虚的。
01,动态多态性的实现
声明虚函数只用在父类对应函数处声明为虚，子类中相应的函数自动变成虚的

#include<iostream>
using namespace std;

class father
{
public:
	virtual void show();
};
class son:public father
{
public:
 void show();
};
void father::show()
{
	cout << "father" << endl;
}
void son::show()
{
	cout << "son" << endl;
}
int main()
{
	father f1;
	father* pt = &f1;
	pt->show();
	son s1;
	pt = &s1;
	pt->show();
}

可以看到，虽然pt为指向father类型的指针，但调用的虚函数所属的类是根据当前pt指向的类决定的

2.为什么C++ 中空类的大小是1个字节？

1、对于结构体和空类大小是 1个字节 这个问题，首先这是一个C++问题，在C语言下空结构体大小为0 （当然这是编译器相关的）。这里的空类和空结构体是指类或结构体中没有任何成员。

2、在C++下，空类和空结构体的大小是1（编译器相关），这是为什么呢？为什么不是0？

3、这是因为，C++标准中规定，“no object shall have the same address in memory as any other variable” ，就是任何不同的对象不能拥有相同的内存地址。 如果空类大小为0，若我们声明一个这个类的对象数组，那么数组中的每个对象都拥有了相同的地址，这显然是违背标准的。

3.查看空类大小，然后添加虚函数再查看
定义一个空类（没有显式的任何成员）

class kong
{

};
int main()
{
	kong k1;
	cout << sizeof(k1)<<endl;
	cout << sizeof(kong)<<endl;
}

可以看到类与其实例化后的对象所占空间大小一样，都为一个字节
为其添加一个非虚函数，并使用同样的main函数：

class kong
{
	void kong1() {};
};

结果也是如此
添加虚函数：

class kong
{
	void kong1() {};
	virtual void kongv() {};
};

添加int型（64位系统下为4字节）数据成员：

class kong
{
	void kong1() {};
	virtual void kongv() {};
	int a;
};

由此我们可以猜想类的内存模型为虚函数表指针与数据成员：

其中vtptr占了四个字节，i为其数据成员

4.验证内存模型
先为father类添加一个数据成员a和一个虚函数show2（）

class father
{
public:
	virtual void show1();
	virtual void show2();
	int a=1;
};
void father::show2()
{
	cout << "father2" << endl;
}

int main()
{
	father f1;
	father* pt = &f1;
	pt->show1();
	cout << *(unsigned int*)(&f1) << endl;
	father f2;
	cout << *(unsigned int*)(&f2) << endl;
	cout << *((unsigned int*)(&f2)+1) << endl;	
}

(&f1)为取内存模型的地址，再解引用即是取其中第一个成员，+1再解引用就是取第二个成员
f1内存模型中第一个成员，即虚函数表指针，显示出来的即为虚表的首地址

可以看到，同一个类的不同实例化的对象，其虚表的地址一样

int main()
{
	father f1;
	father* pt = &f1;
	cout << (unsigned int*)(&f1) << endl;
	father f2;
	cout << (unsigned int*)(&f2) << endl;
}

可以看到，即使是同一个类的对象，他们模型存放的地址也不同（00EFFB74和00EFFB58），但其中放的指向虚表的指针是同一个（15571964）(画图时重新跑了代码，和上面贴出的运行结果略有不同，但原理一样）
由此我们得出结论，虚函数表指针与对象一一对应，虚表与类一一对应

示意图如下：

5.查看虚函数表内存模型
由于void类型函数的地址无法转换并打印，因此先将上述show1，show2换成int型的
并在父类中添加虚函数show2（），并为其增加一个子类son：

class father
{
public:
	virtual int show1();
	virtual int show2();
	int a=9;
};
class son:public father
{
public:
	virtual int show1();
	
};

int main()
{
	father f1;
	father* pt = &f1;
	son s1;
	cout << "f1内存模型地址"<<(unsigned int*)(&f1) << endl;
	cout << "s1内存模型地址" << (unsigned int*)(&s1) << endl;
	cout <<"father类虚表地址"<< *(unsigned int*)(&f1) << endl;
	cout << "son类虚表地址" << *(unsigned int*)(&s1) << endl;
	cout << "通过father类虚函数表查看father类中show1（）函数地址" << *(unsigned int*)*(unsigned int*)(&f1)<< endl;
	cout << "通过father类虚函数表查看father类中show2（）函数地址"<<*(unsigned int*)(*(unsigned int*)(&f1)+1) << endl;
	cout << "通过son类虚函数表查看father类中show1（）函数地址" << *(unsigned int*)*(unsigned int*)(&s1) << endl;
	cout << "通过son类虚函数表查看father类中show2（）函数地址" << *(unsigned int*)(*(unsigned int*)(&s1)+1) << endl;
}

可以通过访问虚函数表的第二个元素查看的父类和派生类对象的虚函数表访问的同一个虚函数地址相同。
这是因为在派生类son中没有重新定义虚函数show2（），但虚表中需要保存该对象的所有虚函数，故将show2的原始版本保存在表中。
示意图如下：

6.虚函数的使用
再回头分析虚函数的使用

int main()
{
	father f1;
	father* pt = &f1;
	pt->show();
	son s1;
	pt = &s1;
	pt->show();
}

pt指向f1时，此时调用虚函数show1（）将先通过f1的虚函数表指针找到虚函数表，再通过虚函数表的show1（）的地址找到Father类的show1

当pt指向s1时，此时的虚函数表为son类的虚函数表，将调用son的show1（）；

7.虚析构

#include<iostream>
using namespace std;
class parent
{
public:
	parent()
	{
		cout << "父类构造" << endl;
	}
		~parent()
	{
		cout << "父类析构" << endl;
	}
};
class son:public parent
{
public:
	son()
	{
		cout << "子类构造" << endl;
	}
		~son()
	{
		cout << "子类析构" << endl;
	}
};
int main()
{
	son s1;
}

当直接通过实例化构造时，调用顺序如下：

不会出现问题
当通过new一个子类对象动态分配内存时

int main()
{
	son* s1 = new son;
}

将不会自动调用析构函数，将会造成内存泄漏：

因此需要手动删除

int main()
{
	son* s1 = new son;
	delete s1;
}

可以看到没啥问题

若是通过父类指针来new

int main()
{
	parent* p1 = new son;
	delete p1;
}

可以看到没有调用子类的析构函数，
这是因为delete p1时调用析构函数的类取决于p1的类型，直接调用父类析构，子类比父类多的东西没有删除，将造成内存泄漏

为了解决这个父类指针动态开辟内存后删除该指针会造成内存泄漏这个问题，引入虚析构

#include<iostream>
using namespace std;
class parent
{
public:
	parent()
	{
		cout << "父类构造" << endl;
	}
	virtual ~parent()
	{
		cout << "父类析构" << endl;
	}

};
class son:public parent
{
public:
	son()
	{
		cout << "子类构造" << endl;
	}
	~son()
	{
		cout << "子类析构" << endl;
	}
};
int main()
{
	//son* s1 = new son;
	parent* p1 = new son;
	delete p1;
}

将不会造成内存泄漏

这是因为将析构函数声明为虚函数后，析构函数会放到虚函数表中
示意图如下：（内存模型用的上面例子的，修改麻烦就没有修改）

可以看到即使p1的类型的指向parent指针，但他指向了子类对象，将根据子类对象的虚函数表指针找到子类的虚函数表，调用子类析构，随后调用父类析构，不会造成内存泄漏

首先虚析构和纯虚析构都是为了解决多态中子类有堆区数据，父类释放时无法释放子类的堆区数据而导致内存泄露的问题。

虚析构和纯虚析构都能解决上述问题，但是虚析构和纯虚析构有很大的不同。

1.语法不同

虚析构语法: virtual~ 类名(){}; 虚析构也需要实现内部函数

纯虚析构语法: virtual~类名() = 0; 纯虚析构也需要实现内部函数，但是是在内外

实现方式 作用域::~类名(){};

2.纯虚析构函数写了之后，这个类也属于抽象类，而无法实例化对象。

下面是具体代码实例:

class Animal
{
public:

	Animal()
	{
		cout << "Animal的构造函数调用" << endl;
	}

	//利用虚析构能够解决父类指针释放子类对象时不干净的问题
	//virtual ~Animal()
	//{
	//	cout << "Animal的虚析构函数调用" << endl;
	//}

	//纯虚析构  需要声明 也需要实现
	//有了纯虚析构之后，这个类也属于抽象类无法实例化对象
	virtual ~Animal() = 0;

	//纯虚函数
	virtual void Speak() = 0;
};

Animal:: ~Animal()
{
	cout << "Animal的纯虚析构函数调用" << endl;
}

class Cat :public Animal
{
public:

	Cat(string name)
	{
		cout << "Cat的构造函数调用" << endl;
		m_Name = new string(name);
	}

	~Cat()
	{
		assert(m_Name);
		cout << "Cat的析构函数调用" << endl;
		delete m_Name;
		m_Name = NULL;
	}

	virtual void Speak()
	{
		cout << *m_Name <<"小猫在说话" << endl;
	}

	string* m_Name;
};

void Test1()
{
	Animal* animal = new Cat("Tom");
	animal->Speak();
	//父类的指针在析构的时候 不会调用子类中析构函数，导致子类如果有堆区属性，会出现内存泄露
	delete animal;
}

int main()
{
	Test1();

	system("pause");
	return 0;
}

输出结果: