八、多态、虚析构

能吃怎么了

已于 2023-08-24 12:18:33 修改

阅读量36

点赞数

分类专栏： C++ 文章标签： c++ visual studio

于 2022-10-07 15:50:29 首次发布

本文链接：https://blog.csdn.net/shkzw/article/details/127192827

版权

C++ 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、基于虚函数（virtual）的多态

#include <iostream>
using namespace std;

class CWater
{
public:
	void Show() 
	{
		cout << "CWater :: Show" << endl;
	}
};

class CBeer : public CWater
{
public:
	void Show()
	{
		cout << "CBeer :: Show" << endl;
	}

};

class CMilk : public CWater
{
public:
	void Show()
	{
		cout << "CMilk :: Show" << endl;
	}

};

class CCoco : public CWater
{
public:
	void Show()
	{
		cout << "CCoco :: Show" << endl;
	}

};

//==============================================================

void Bottle(CWater *p)
{
	p->Show();
}

int main()
{
	CBeer *beer = new CBeer;
	CMilk *milk = new CMilk;
	CCoco *coco = new CCoco;

	Bottle(beer);
	Bottle(milk);
	Bottle(coco);


	system("pause");
	return 0;
}

输出结果为：

出现了上节所提到的问题：父类无法调用子类的成员函数。

解决方式为：多态—虚函数的使用

输出结果为：

虚函数：通过父类的指针调用实际的子类的成员函数，前提是子类中需要重写这个函数，重写是名一样，参数列表也一样

如上图所示，只能输出第一个函数Show()，因为它与父类函数名一样，参数列表也一样。

多态提高了复用性和扩展性。

https://blog.csdn.net/qmroom/article/details/3085356

二、多态的实现原理

★调用函数的两种方式：

#include <iostream>
using namespace std;

void Show(int a)
{
   cout << "AA" << a << endl;
}

int main()
{
   //函数名(); //调用函数的方法—>功能是固定的
   Show(1);

   //（*函数指针名）(); //调用函数指针的方法—>功能是可变的，可扩展的
   void (*p)(int a); //定义一个函数指针
   p = &Show;//给函数指针赋值
   (*p)(2);

   system("pause");
   return 0;
}

//========================================================================

定义一个父类，函数参数为空，输出长度为1。

#include <iostream>
using namespace std;

class CFather
{
public:
	void AA()
	{
		cout << "CFather :: AA" << endl;
	}
};

int main()
{
	cout << sizeof(CFather) << endl; //输出长度为1

	system("pause");
	return 0;
}

加上虚函数，再次运行，输出长度为4，是一个函数指针。

//=======================================================================

在父类中定义三个函数，两个虚函数AA和BB，普通函数CC，主函数中定义函数指针，并开辟父类空间

#include <iostream>
using namespace std;

class CFather
{
public:
	virtual void AA()
	{
		cout << "CFather :: AA" << endl;
	}
	virtual void BB()
	{
		cout << "CFather :: BB" << endl;
	}
	void CC()
	{
		cout << "CFather :: CC" << endl;
	}
};
 
int main()
{
	cout << sizeof(CFather) << endl; 
	CFather*p = new CFather;

	system("pause");
	return 0;
}

在system("pause");处下断点，可以发现，父类指针p是一个函数指针，其中包括虚函数AA和BB （都是父类的）

//========================================================================

接上文，再设计一个子类，包括三个函数，两个虚函数（AA和DD），一个普通函数（CC）；并改为开辟子类空间。

#include <iostream>
using namespace std;

class CFather
{
public:
	virtual void AA()
	{
		cout << "CFather :: AA" << endl;
	}
	virtual void BB()
	{
		cout << "CFather :: BB" << endl;
	}
	void CC()
	{
		cout << "CFather :: CC" << endl;
	}
};

class CSon : public CFather
{
	virtual void AA()
	{
		cout << "CFather :: AA" << endl;
	}
	void CC()
	{
		cout << "CFather :: CC" << endl;
	}
	virtual void DD()
	{
		cout << "CFather :: DD" << endl;
	}

};
 
int main()
{
	cout << sizeof(CFather) << endl; 
	CFather*p = new CSon;

	system("pause");
	return 0;
}

在system("pause");处下断点，可以发现，父类指针p是一个函数指针，其中包括虚函数AA和BB （AA是子类的；BB是父类的，因为子类中未定义虚函数BB；之所以没有虚函数DD，是因为定义的是父类指针，只能看到父类成员的变化）

总结：

每个类中定义的多个函数构成了一个虚函数列表，开辟父类空间则vfptr调用父类虚函数列表，开辟子类空间则vfptr调用子类虚函数列表。若子类重写了父类的函数，则重写的覆盖了父类函数，开辟子类空间，输出为重写的。虚函数输出长度为4，多出来的就是vfptr，它标记了对象调用哪个虚函数列表。

//========================================================================

★怎样取出虚函数列表里的内容？

CFather*p = new CSon;//p指向对象空间的首地址，但只想要前四个字节（vfptr）的首地址

对象前4个字节vfptr（是一个二级指针）装了数组的首地址，数组的每个元素装了函数的地址，那么，怎样拿到函数的地址？

注意：函数指针不能进行地址偏移，因为函数几个字节不知道。每个指针占4个字节，只要从首地址向后偏移4个字节就能拿到下一个元素。

*(int*)p代表数组的首地址，因为地址的类型就是函数的类型（里面每个元素都是函数指针，不能做地址偏移），因此将它当作整型地址，可以向后偏移4个字节，((int*)*(int*)p+1)得到每个元素的地址。*((int*)*(int*)p+1)就取得这个地址对应的内存空间的内容，这个内容就是函数的地址。

#include <iostream>
using namespace std;

class CFather
{
public:
	virtual void AA()
	{
		cout << "CFather :: AA" << endl;
	}
	virtual void BB()
	{
		cout << "CFather :: BB" << endl;
	}
	void CC()
	{
		cout << "CFather :: CC" << endl;
	}
};

class CSon : public CFather
{
	virtual void AA()
	{
		cout << "CFather :: AA" << endl;
	}
	void CC()
	{
		cout << "CFather :: CC" << endl;
	}
	virtual void DD()
	{
		cout << "CFather :: DD" << endl;
	}

};
 
int main()
{
	cout << sizeof(CFather) << endl; 
	CFather*p = new CSon;//p指向对象空间的首地址，但只想要前四个字节（vfptr）的首地址
	typedef void (*PFUN)();

	PFUN  aa = (PFUN)*((int*)*(int*)p+0);//取得这个地址前4个字节装的内容，这个内容是虚函数列表的首地址。那怎样拿出每个元素呢？ 
	PFUN  bb = (PFUN)*((int*)*(int*)p+1);
	PFUN  cc = (PFUN)*((int*)*(int*)p+2);
	PFUN  dd = (PFUN)*((int*)*(int*)p+3);

	(*cc)();

	system("pause");
	return 0;
}

本节详见视频12-1

三、虚析构

虚析构：通过父类的指针完整删除一个子类的对象，防止内存泄漏。

#include <iostream>
using namespace std;

class CFather
{
public:
	CFather()
	{
		cout << "CFather" << endl;
	}
	virtual ~CFather()
	{
		cout << "~CFather" << endl;
	}
};

class CSon : public CFather
{
public:
	CSon()
	{
		cout << "CSon" << endl;
	}
	~CSon()
	{
		cout << "~CSon" << endl;
	}
};
 
int main()
{
	{
		CFather *son = new CSon;
		delete son;
	}

	system("pause");
	return 0;
}

输出结果为：