devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++修炼之路之多态---多态的原理(虚函数表)

作者：IT小白 | 2024-05-16 04:21:18

赞

踩

C++修炼之路之多态---多态的原理(虚函数表)

目录

一：多态的原理 

1.虚函数表

 2.原理分析

3.对于虚表存在哪里的探讨

4.对于是不是所有的虚函数都要存进虚函数表的探讨

二：多继承中的虚函数表

三：常见的问答题 

接下来的日子会顺顺利利，万事胜意，生活明朗-----------林辞忧 

接上篇的多态的介绍后，接下来介绍多态的原理以及虚函数表的相关知识

一：多态的原理 

1.虚函数表

这里从一道经典笔试题引入

对于这道题我们可能想到的是计算类 大小的对齐规则，结果为4，但结果为8，这是因为有虚函数的类要多考虑一指针

在32位系统下是8

如果这里再添加几个虚函数呢？

 

所以在这里不管类里面有多少个虚函数 ，只要是包含虚函数的类计算大小都要考虑添加一指针，再考虑对齐

但这里的一指针是什么呢？

但这里我们就看到在b1中除了_b还存有 一个_vfptr的指针在对象的前面，这个指针就叫做虚函数表指针，其中v代表virtual,f代表funcation

每一个含有虚函数的类都至少有一个虚函数表指针，他的类型为函数指针数组，而虚函数的地址是存放在虚函数表中的，虚函数表也叫虚表

 2.原理分析

  1. class Base
  2. {
  3. public:
  4. 	virtual void Func1()
  5.     {
  6. 		cout << "Func1()" << endl;
  7.     }
  8. 	virtual void Func2()
  9. 	{
  10. 		cout << "Func2()" << endl;
  11. 	}
  12. 	
  13. private:
  14. 	int _b = 1;
  15. };
  16. class Derived : public Base
  17. {
  18. 	virtual void Func1()
  19. 	{
  20. 		cout << "Func()" << endl;
  21. 	}
  22. private:
  23. 	int _a = 0;
  24. };
  25.  
  26. int main()
  27. {
  28. 	Base b1;
  29. 	Derived d1;
  30. 	return 0;
  31. }

 

解释多态调用的两个条件

对于条件一：必须是父类的指针或引用来调用函数

1.父类的指针指向父类对象时，依据虚函数表指针(vfptr)，在虚函数表中找到函数的地址，再call这个地址来执行接下来的操作

2.父类的指针指向子类对象时，先完成切片，找到父类的那一部分，依据虚函数表指针(vfptr)，在虚函数表中找到函数的地址，再call这个地址来执行接下来的操作

3.由于经过虚函数的重写后，虚函数的地址是不相同的，所以结果是不相同的，这是就形成了多态

对于编译器来说上面的两个调用是执行的同样的操作，都只是取对象的头四个字节，就是虚函数表指针，然后去虚表中找到对应调用函数的地址，然后执行接下来的操作

4.如果是父类的对象调用函数的话这时就要分析可能会总成的结果

这时尤其是这样的场景，Person* ptr=new Person,Student s;   *ptr=s ,这样如果支持能拷贝虚函数表指针的话，这时delete  ptr,就调用的是 Student类的析构函数，导致直接错误的

5.对于多态调用是在运行时，去虚表里面找到函数指针，确定函数指针后，调用函数；

对于普通调用是在编译链接时，确定函数地址

6.派生类中只有一个虚表指针（菱形继承除外），同一个类的对象共用一张虚表

7.虚函数也是也是和成员函数一样存在代码段的，不同的是虚函数会将自己的地址存在虚表中

对于条件二：虚函数的重写

从上面就可以看出虚函数的重写也叫覆盖，覆盖了原先虚函数的地址，重写是语法层的叫法，而覆盖是原理层的叫法

三：派生类的虚表生成

1.先将基类中的虚表内容拷贝一份到派生类的虚表中

2.如果派生类重写了基类中的某个虚函数，用派生类自己的虚函数的地址来覆盖虚表中基类的虚函数地址

3.派生类自己新增的虚函数按其在派生类中的声明顺序增加到派生类虚表的最后

3.对于虚表存在哪里的探讨

对于栈和堆是不可能的，只有代码段或者静态区，但我们可以自己验证是存在哪里的

验证代码

  1. class Base {
  2. public:
  3. 	virtual void func1() { cout << "Base::func1" << endl; }
  4. 	virtual void func2() { cout << "Base::func2" << endl; }
  5. private:
  6. 	int a;
  7. };
  8. void func()
  9. {
  10. 	cout << "void func()" << endl;
  11. }
  12. int main()
  13. {
  14. 	Base b1;
  15. 	Base b2;
  16.  
  17. 	static int a = 0;
  18. 	int b = 0;
  19. 	int* p1 = new int;
  20. 	const char* p2 = "hello world";
  21. 	printf("静态区:%p\n", &a);
  22. 	printf("栈:%p\n", &b);
  23. 	printf("堆:%p\n", p1);
  24. 	printf("代码段:%p\n", p2);
  25. 	printf("虚表:%p\n", *((int*)&b1));
  26. 	printf("虚函数地址:%p\n", &Base::func1);
  27. 	printf("普通函数地址:%p\n", func);
  28.  
  29. 	return 0;
  30. }

对于这里的取虚表地址

 

可以这样来理解，&b1是整个类的地址，然后强转为(int*),再解引用取得就是头四个字节，即虚表地址 

 

我们发现 和虚表地址最接近的为代码段的地址，所以可以确定虚表是存在代码段的

4.对于是不是所有的虚函数都要存进虚函数表的探讨

首先确定答案 一定都是存在虚函数表的

接下来我们在vs上监视窗口来查看

分析代码

  1. class Base {
  2. public:
  3. 	virtual void func1() { cout << "Base::func1" << endl; }
  4. 	virtual void func2() { cout << "Base::func2" << endl; }
  5. private:
  6. 	int a;
  7. };
  8.  
  9. class Derive :public Base {
  10. public:
  11. 	virtual void func1() { cout << "Derive::func1" << endl; }
  12. 	virtual void func3() { cout << "Derive::func3" << endl; }
  13. 	virtual void func4() { cout << "Derive::func4" << endl; }
  14. 	void func5() { cout << "Derive::func5" << endl; }
  15. private:
  16. 	int b;
  17. };
  18.  
  19. class X :public Derive {
  20. public:
  21. 	virtual void func3() { cout << "X::func3" << endl; }
  22. };
  23.  
  24. int main()
  25. {
  26. 	Base b;
  27. 	Derive d;
  28. 	X x;
  29.  
  30. 	Derive* p = &d;
  31. 	p->func3();
  32.  
  33. 	p = &x;
  34. 	p->func3();
  35.  
  36. 	return 0;
  37. }

  

对于这里监视窗口的显示，在这里对于b是只有两个虚函数都存进了虚函数表中，但对于d和x都应该是四个虚函数存进虚函数表的，但在这里都只存了两个虚函数，但验证多态调用的话，结果为

结果是多态调用， 这时我们就不得不质疑此时监视窗口 的结果了

为了进一步的证明。我们可以调用内存窗口来查看

在内存中我们就会发现后两个地址与前两个虚函数的地址很接近，所以我们暂时可以认为虚函数是都存在虚函数表中的，

为了确定结果，我们可以使用打印虚表来验证猜想

  1. class Base {
  2. public:
  3. 	virtual void func1() { cout << "Base::func1" << endl; }
  4. 	virtual void func2() { cout << "Base::func2" << endl; }
  5. private:
  6. 	int a;
  7. };
  8.  
  9. class Derive :public Base {
  10. public:
  11. 	virtual void func1() { cout << "Derive::func1" << endl; }
  12. 	virtual void func3() { cout << "Derive::func3" << endl; }
  13. 	virtual void func4() { cout << "Derive::func4" << endl; }
  14. 	void func5() { cout << "Derive::func5" << endl; }
  15. private:
  16. 	int b;
  17. };
  18.  
  19. class X :public Derive {
  20. public:
  21. 	virtual void func3() { cout << "X::func3" << endl; }
  22. };
  23.  
  24. typedef void (*VFUNC)();
  25. //void PrintVFT(VFUNC a[])
  26. void PrintVFT(VFUNC* a)
  27. {
  28. 	for (size_t i = 0; a[i] != 0; i++)
  29. 	{
  30. 		printf("[%d]:%p->", i, a[i]);
  31. 		VFUNC f = a[i];
  32. 		f();
  33. 		//(*f)();
  34. 	}
  35. 	printf("\n");
  36. }
  37.  
  38. int main()
  39. {
  40. 	Base b;
  41. 	PrintVFT((VFUNC*)(*((long long*)&b)));//32位的话，可以采用int
  42.  
  43. 	Derive d;
  44. 	X x;
  45.  
  46. 	// PrintVFT((VFUNC*)&d);
  47. 	PrintVFT((VFUNC*)(*((long long*)&d)));
  48.  
  49. 	PrintVFT((VFUNC*)(*((long long*)&x)));
  50.  
  51. 	return 0;
  52. }

 

这样看，只要是虚函数，都会将地址存到类的虚函数表里面的

 

二：多继承中的虚函数表

同样的我们可以采用例子来介绍

  1. class Base1 {
  2. public:
  3. 	virtual void func1() { cout << "Base1::func1" << endl; }
  4. 	virtual void func2() { cout << "Base1::func2" << endl; }
  5. private:
  6. 	int b1;
  7. };
  8.  
  9. class Base2 {
  10. public:
  11. 	virtual void func1() { cout << "Base2::func1" << endl; }
  12. 	virtual void func2() { cout << "Base2::func2" << endl; }
  13. private:
  14. 	int b2;
  15. };
  16.  
  17. class Derive : public Base1, public Base2 {
  18. public:
  19. 	virtual void func1() 
  20. 	{ 
  21. 		cout << "Derive::func1" << endl;
  22. 	}
  23.  
  24. 	virtual void func3() { cout << "Derive::func3" << endl; }
  25. private:
  26. 	int d1;
  27. };
  28.  
  29. int main()
  30. {
  31. 	Derive d;
  32.  
  33. 	Base1* p1 = &d;
  34. 	p1->func1();
  35.  
  36. 	Base2* p2 = &d;
  37. 	p2->func1();
  38.  
  39. 	return 0;
  40. }

采用监视窗口的话 

就会发现对于基类的两张虚表中都没有存derived类的fun3() ，但我们可以使用多态的调用来验证下

所以的话，fun3是一定存在基类的两张 虚表中的其中一个里面，这样采用内存来看

所以最好的方式，我们还是来打印两个基类的虚函数表的 

  1. typedef void (*VFUNC)();
  2. //void PrintVFT(VFUNC a[])
  3. void PrintVFT(VFUNC* a)
  4. {
  5. 	for (size_t i = 0; a[i] != 0; i++)
  6. 	{
  7. 		printf("[%d]:%p->", i, a[i]);
  8. 		VFUNC f = a[i];
  9. 		f();
  10. 		//(*f)();
  11. 	}
  12. 	printf("\n");
  13. }
  14. class Base1 {
  15. public:
  16. 	virtual void func1() { cout << "Base1::func1" << endl; }
  17. 	virtual void func2() { cout << "Base1::func2" << endl; }
  18. private:
  19. 	int b1;
  20. };
  21.  
  22. class Base2 {
  23. public:
  24. 	virtual void func1() { cout << "Base2::func1" << endl; }
  25. 	virtual void func2() { cout << "Base2::func2" << endl; }
  26. private:
  27. 	int b2;
  28. };
  29.  
  30. class Derive : public Base1, public Base2 {
  31. public:
  32. 	virtual void func1() 
  33. 	{ 
  34. 		cout << "Derive::func1" << endl;
  35. 	}
  36.  
  37. 	virtual void func3() { cout << "Derive::func3" << endl; }
  38. private:
  39. 	int d1;
  40. };
  41.  
  42. int main()
  43. {
  44. 	Derive d;
  45.      PrintVFT((VFUNC*)(*(int*)&d));
  46.  
  47.      //PrintVFT((VFUNC*)(*(int*)((char*)&d+sizeof(Base1))));
  48.      Base2* ptr = &d;
  49.      PrintVFT((VFUNC*)(*(int*)ptr));
  50.  
  51. 	
  52. 	/*Base1* p1 = &d;
  53. 	p1->func1();
  54.  
  55. 	Base2* p2 = &d;
  56. 	p2->func1();*/
  57.  
  58. 	return 0;
  59. }

 

所以此时我们就会知道，派生类的虚函数地址是存在第一个基类的虚函数表里面的 

三：常见的问答题 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/576875
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号