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

c++虚函数表、地址详解_虚函数表存在什么位置

作者：知新_RL | 2024-03-15 19:35:39

赞

踩

虚函数表存在什么位置

一.什么是虚函数表，它有什么特点？

虚函数大家都知道是基本用于实现多态的，当父类指针指向子类对象的时候，如何确定调用的函数是父类里的还是子类里面的，这就要用到虚函数表。下面一点点表诉什么是虚函数表，和虚函数表的特点。如有说错的地方，欢迎指正：

1.编译器会为每个有虚函数的类创建一个虚函数表

如有类中没有虚函数，那么这个虚函数表就不存在，而不是表中无数据。同时，所有类都会有自己的虚函数表，一个类不会有另外一个类的虚函数表，包括两个类属于继承关系。

2.虚函数表会被一个类的所有对象所拥有

类的每个虚函数成员占据虚函数表的一行，所以说，如果类中有N个虚函数,那么该虚函数表将会有N*4的大小。并不是每个类对象都会有自己的表。

3.编译器会将虚函数表指针存放在类对象最前面的位置

对于类的每个对象，编译器都会为其生成一个透明不可见的指针，这个指针就是虚函数表指针，存放在该对象内存的最前位置。例如：一个类拥有虚函数表，类对象内存布局中前4个字节就是虚函数表的地址（32位）。这个接下来我们会进行测试。

4.延伸，由第一条可知，子类继承父类，其虚函数表和表函数地址是不一样的。
5.父类指针指向子类时，调用时实际上是根据子类的虚函数表进行查找

二、测试

测试内容：
虚函数表地址和虚函数地址存放位置？
多个类对象的虚函数表地址是否一样？
测试类中无虚函数，是否存在虚函数表？
子类继承父类虚函数表地址分别是什么位置？
子类重写父类中虚函数或子类重定义父类虚函数虚函数表是否发生改变？
子类指针指向父类虚函数表是什么样子？

1.测试虚函数表地址和虚函数地址

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <iostream>
  4.  
  5. using namespace std;
  6.  
  7. class Father
  8. {
  9. 	virtual void FatherFun1() {cout << "FatherFun1" <<endl;}
  10. 	virtual void FatherFun2() {cout << "FatherFun2" <<endl;}
  11. 	virtual void FatherFun3() {cout << "FatherFun3" <<endl;}
  12. };
  13.  
  14. typedef void (*Fun)(void);
  15.  
  16. int main()
  17. {
  18. 	Father father;
  19. 	cout << "类对象地址：" << &father << endl;
  20. 	cout << "虚函数表地址: " << (int*)*(int*)&father << endl;
  21. 	cout << "虚函数FatherFun1地址：" <<(int*)*(int*)&father << endl;
  22. 	cout << "虚函数FatherFun2地址：" <<(int*)*(int*)&father + 1 << endl;
  23. 	cout << "虚函数FatherFun3地址：" <<(int*)*(int*)&father + 2 << endl;
  24.  
  25. 	cout << "测试地址是否正确" << endl;
  26. 	Fun fun = (Fun)*(int*)*(int*)&father;
  27. 	fun();
  28. 	fun = (Fun)*((int*)*(int*)(&father) + 1);
  29. 	fun();
  30. 	fun = (Fun)*((int*)*(int*)(&father) + 2);
  31. 	fun();
  32.  
  33. 	system("pause");
  34. }

上面说过类对象内存中前4个字节就是虚函数表的地址，那么我们获取类对象前4个字节，（int）&father就是虚函数表地址，我们再给他转换成地址指针为（int*)（int）&father。

然后我们在看一下输出结果：

  1. 类对象地址：003BF90C
  2. 虚函数表地址: 00867898
  3. 虚函数FatherFun1地址：00867898
  4. 虚函数FatherFun2地址：0086789C
  5. 虚函数FatherFun3地址：008678A0
  6. 测试地址是否正确
  7. FatherFun1
  8. FatherFun2
  9. FatherFun3
  10. 请按任意键继续. . .

从这个输出我们可以看到，FatherFun1、FatherFun2、FatherFun3的地址只差了4个字节，且输出是正确的，那么第三点已确认！

2.多个类对象的虚函数表地址

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <iostream>
  4.  
  5. using namespace std;
  6.  
  7. class Father
  8. {
  9. 	virtual void FatherFun1() {cout << "FatherFun1" <<endl;}
  10. 	virtual void FatherFun2() {cout << "FatherFun2" <<endl;}
  11. 	virtual void FatherFun3() {cout << "FatherFun3" <<endl;}
  12. };
  13.  
  14. typedef void (*Fun)(void);
  15.  
  16. int main()
  17. {
  18.  
  19. 	Father father;
  20. 	cout << "类对象地址：" << &father << endl;
  21. 	cout << "虚函数表地址: " << (int*)*(int*)&father << endl;
  22. 	cout << "虚函数FatherFun1地址：" <<(int*)*(int*)&father << endl;
  23. 	cout << "虚函数FatherFun2地址：" <<(int*)*(int*)&father + 1 << endl;
  24. 	cout << "虚函数FatherFun3地址：" <<(int*)*(int*)&father + 2 << endl;
  25.  
  26. 	cout << "第二个类对象" << endl;
  27.  
  28. 	Father father1;
  29. 	cout << "类对象地址：" << &father1 << endl;
  30. 	cout << "虚函数表地址: " << (int*)*(int*)&father1 << endl;
  31. 	cout << "虚函数FatherFun1地址：" <<(int*)*(int*)&father1 << endl;
  32. 	cout << "虚函数FatherFun2地址：" <<(int*)*(int*)&father1 + 1 << endl;
  33. 	cout << "虚函数FatherFun3地址：" <<(int*)*(int*)&father1 + 2 << endl;
  34.  
  35. 	system("pause");
  36. }

定义了两个对象，分别看两个对象的虚函数表地址是否正确，发现两个类对象虚函数表地址相同。

以下为输出：

  1.   类对象地址：0020F9C8
  2.   虚函数表地址: 00B37894
  3.   虚函数FatherFun1地址：00B37894
  4.   虚函数FatherFun2地址：00B37898
  5.   虚函数FatherFun3地址：00B3789C
  6.   第二个类对象
  7.   类对象地址：0020F9BC
  8.   虚函数表地址: 00B37894
  9.   虚函数FatherFun1地址：00B37894
  10.   虚函数FatherFun2地址：00B37898
  11.   虚函数FatherFun3地址：00B3789C
  12.   请按任意键继续. . .

由此可见，第二点现在已经确认！

3.测试类中无虚函数，是否存在虚函数表

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <iostream>
  4.  
  5. using namespace std;
  6.  
  7.  
  8. class Test
  9. {
  10. 	 void TestFun1() {cout << "TestFun1" <<endl;}
  11. 	 void TestFun2() {cout << "TestFun2" <<endl;}
  12. 	 void TestFun3() {cout << "TestFun3" <<endl;}
  13. };
  14.  
  15. typedef void (*Fun)(void);
  16.  
  17. int main()
  18. {
  19. 	Test test;
  20. 	cout << "类对象地址：" << &test << endl;
  21. 	cout << "虚函数表地址: " << (int*)*(int*)&test << endl;
  22. 	cout << "虚函数TestFun1地址：" <<(int*)*(int*)&test << endl;
  23. 	cout << "虚函数TestFun2地址：" <<(int*)*(int*)&test + 1 << endl;
  24. 	cout << "虚函数TestFun3地址：" <<(int*)*(int*)&test + 2 << endl;
  25.  
  26. 	system("pause");
  27. }

以下为输出：

  1.   类对象地址：0041FCEB
  2.   虚函数表地址: CCCCCCCC
  3.   虚函数TestFun1地址：CCCCCCCC
  4.   虚函数TestFun2地址：CCCCCCD0
  5.   虚函数TestFun3地址：CCCCCCD4
  6.   请按任意键继续. . .

由此可见虚函数表地址为错误，第一条确认！

4.子类继承父类，但不继承虚函数表

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <iostream>
  4.  
  5. using namespace std;
  6.  
  7. class Father
  8. {
  9. 	virtual void FatherFun1() {cout << "FatherFun1" <<endl;}
  10. 	virtual void FatherFun2() {cout << "FatherFun2" <<endl;}
  11. 	virtual void FatherFun3() {cout << "FatherFun3" <<endl;}
  12. };
  13.  
  14. class Son : public Father
  15. {
  16. 	virtual void SonFun1() {cout << "SonFun1" <<endl;}
  17. 	virtual void SonFun2() {cout << "SonFun2" <<endl;}
  18. 	virtual void SonFun3() {cout << "SonFun3" <<endl;}
  19. };
  20.  
  21. typedef void (*Fun)(void);
  22.  
  23. int main()
  24. {
  25. 	Father father;
  26. 	cout << "类对象地址：" << &father << endl;
  27. 	cout << "虚函数表地址: " << (int*)*(int*)&father << endl;
  28. 	cout << "虚函数FatherFun1地址：" <<(int*)*(int*)&father << endl;
  29. 	cout << "虚函数FatherFun2地址：" <<(int*)*(int*)&father + 1 << endl;
  30. 	cout << "虚函数FatherFun3地址：" <<(int*)*(int*)&father + 2 << endl;
  31. 	//cout << "虚函数sonFun1地址：" <<(int*)*(int*)&father + 3 << endl;
  32. 	//cout << "虚函数sonFun2地址：" <<(int*)*(int*)&father + 4 << endl;
  33. 	//cout << "虚函数sonFun3地址：" <<(int*)*(int*)&father + 5 << endl;
  34. 	Fun fun = (Fun)*(int*)*(int*)&father;
  35. 	fun();
  36. 	fun = (Fun)*((int*)*(int*)(&father) + 1);
  37. 	fun();
  38. 	fun = (Fun)*((int*)*(int*)(&father) + 2);
  39. 	fun();
  40. 	//fun = (Fun)*((int*)*(int*)(&father) + 3);
  41. 	//fun();
  42. 	//fun = (Fun)*((int*)*(int*)(&father) + 4);
  43. 	//fun();
  44. 	//fun = (Fun)*((int*)*(int*)(&father) + 5);
  45. 	//fun();
  46.  
  47. 	cout << "----------------测试子类------------------" << endl;
  48.  
  49. 	Son son;
  50. 	cout << "类对象地址：" << &son << endl;
  51. 	cout << "虚函数表地址: " << (int*)*(int*)&son << endl;
  52. 	cout << "虚函数继承FatherFun1地址：" <<(int*)*(int*)&son << endl;
  53. 	cout << "虚函数继承FatherFun2地址：" <<(int*)*(int*)&son + 1 << endl;
  54. 	cout << "虚函数继承FatherFun3地址：" <<(int*)*(int*)&son + 2 << endl;
  55. 	cout << "虚函数sonFun1地址：" <<(int*)*(int*)&son + 3 << endl;
  56. 	cout << "虚函数sonFun2地址：" <<(int*)*(int*)&son + 4 << endl;
  57. 	cout << "虚函数sonFun3地址：" <<(int*)*(int*)&son + 5 << endl;
  58. 	fun = (Fun)*(int*)*(int*)&son;
  59. 	fun();
  60. 	fun = (Fun)*((int*)*(int*)(&son) + 1);
  61. 	fun();
  62. 	fun = (Fun)*((int*)*(int*)(&son) + 2);
  63. 	fun();
  64. 	fun = (Fun)*((int*)*(int*)(&son) + 3);
  65. 	fun();
  66. 	fun = (Fun)*((int*)*(int*)(&son) + 4);
  67. 	fun();
  68. 	fun = (Fun)*((int*)*(int*)(&son) + 5);
  69. 	fun();
  70.  
  71. 	system("pause");
  72. }

如果将代码中注释代码给恢复，会直接发生段错误。

以下为输出结果：

类对象地址：0027FCA8
虚函数表地址: 01317930
虚函数FatherFun1地址：01317930
虚函数FatherFun2地址：01317934
虚函数FatherFun3地址：01317938
FatherFun1
FatherFun2
FatherFun3
----------------测试子类------------------
类对象地址：0027FC90
虚函数表地址: 01317974
虚函数继承FatherFun1地址：01317974
虚函数继承FatherFun2地址：01317978
虚函数继承FatherFun3地址：0131797C
虚函数sonFun1地址：01317980
虚函数sonFun2地址：01317984
虚函数sonFun3地址：01317988
FatherFun1
FatherFun2
FatherFun3
SonFun1
SonFun2
SonFun3
请按任意键继续. . .

由输出结果我们可以看到，父类和子类中的虚函数表地址是不一样的，而且子类继承了父类的虚函数，但是其地址是和父类中不一样的！。第四点确认！
并且我们根据输出可以发现，子类虚函数表中虚函数地址排序为先是继承的父类的函数，再是子类中的虚函数。

在这里插入图片描述

5.子类重写父类中虚函数，或子类重定义父类虚函数

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <iostream>
  4.  
  5. using namespace std;
  6.  
  7. class Father
  8. {
  9. 	virtual void FatherFun4() {cout << "FatherFun4" <<endl;}
  10. 	virtual void FatherFun1() {cout << "FatherFun1" <<endl;}
  11. 	virtual void FatherFun2() {cout << "FatherFun2" <<endl;}
  12. 	virtual void FatherFun3() {cout << "FatherFun3" <<endl;}
  13. };
  14.  
  15. class Son : public Father
  16. {
  17. 	virtual void SonFun1() {cout << "SonFun1" <<endl;}
  18. 	virtual void SonFun2() {cout << "SonFun2" <<endl;}
  19. 	virtual void SonFun3() {cout << "SonFun3" <<endl;}
  20. 	virtual void FatherFun4() {cout << "SonGetFatherFun4" <<endl;}
  21. 	virtual void FatherFun4(int a = 0) {cout << "SonGetFatherFun4 diffrent param" <<endl;}
  22. };
  23.  
  24. typedef void (*Fun)(void);
  25. typedef void (*FunParam)(int);
  26.  
  27. int main()
  28. {
  29. #if 1
  30. 	Father father;
  31. 	cout << "类对象地址：" << &father << endl;
  32. 	cout << "虚函数表地址: " << (int*)*(int*)&father << endl;
  33. 	cout << "虚函数FatherFun4地址：" <<(int*)*(int*)&father << endl;
  34. 	cout << "虚函数FatherFun1地址：" <<(int*)*(int*)&father + 1 << endl;
  35. 	cout << "虚函数FatherFun2地址：" <<(int*)*(int*)&father + 2 << endl;
  36. 	cout << "虚函数FatherFun3地址：" <<(int*)*(int*)&father + 3 << endl;
  37. 	Fun fun = (Fun)*(int*)*(int*)&father;
  38. 	fun();
  39. 	fun = (Fun)*((int*)*(int*)(&father) + 1);
  40. 	fun();
  41. 	fun = (Fun)*((int*)*(int*)(&father) + 2);
  42. 	fun();
  43. 	fun = (Fun)*((int*)*(int*)(&father) + 3);
  44. 	fun();
  45. 	
  46.  
  47. 	cout << "----------------测试子类------------------" << endl;
  48.  
  49. 	Son son;
  50. 	cout << "类对象地址：" << &son << endl;
  51. 	cout << "虚函数表地址: " << (int*)*(int*)&son << endl;
  52. 	cout << "虚函数继承SonGetFatherFun4地址：" <<(int*)*(int*)&son << endl;
  53. 	cout << "虚函数继承FatherFun1地址：" <<(int*)*(int*)&son + 1 << endl;
  54. 	cout << "虚函数继承FatherFun2地址：" <<(int*)*(int*)&son + 2 << endl;
  55. 	cout << "虚函数继承FatherFun3地址：" <<(int*)*(int*)&son + 3 << endl;
  56. 	cout << "虚函数sonFun1地址：" <<(int*)*(int*)&son + 4 << endl;
  57. 	cout << "虚函数sonFun2地址：" <<(int*)*(int*)&son + 5 << endl;
  58. 	cout << "虚函数sonFun3地址：" <<(int*)*(int*)&son + 6 << endl;
  59. 	cout << "虚函数SonGetFatherFun4 diffrent param地址：" <<(int*)*(int*)&son + 7 << endl;
  60. 	fun = (Fun)*(int*)*(int*)&son;
  61. 	fun();
  62. 	fun = (Fun)*((int*)*(int*)(&son) + 1);
  63. 	fun();
  64. 	fun = (Fun)*((int*)*(int*)(&son) + 2);
  65. 	fun();
  66. 	fun = (Fun)*((int*)*(int*)(&son) + 3);
  67. 	fun();
  68. 	fun = (Fun)*((int*)*(int*)(&son) + 4);
  69. 	fun();
  70. 	fun = (Fun)*((int*)*(int*)(&son) + 5);
  71. 	fun();
  72. 	fun = (Fun)*((int*)*(int*)(&son) + 6);
  73. 	fun();
  74. 	FunParam funParam= (FunParam)*((int*)*(int*)(&son) + 7);
  75. 	funParam(0);
  76. #endif
  77. 	system("pause");
  78. }

我们故意将父类中FatherFun4放在最前，而子类中的重写和重定义的FatherFun4 函数放在最后，看一下虚函数表中虚函数排放顺序是否有发生改变。

以下为输出结果：

  1.   类对象地址：0021FD4C
  2.   虚函数表地址: 011479B8
  3.   虚函数FatherFun4地址：011479B8
  4.   虚函数FatherFun1地址：011479BC
  5.   虚函数FatherFun2地址：011479C0
  6.   虚函数FatherFun3地址：011479C4
  7.   FatherFun4
  8.   FatherFun1
  9.   FatherFun2
  10.   FatherFun3
  11.   ----------------测试子类------------------
  12.   类对象地址：0021FD34
  13.   虚函数表地址: 01147A10
  14.   虚函数继承SonGetFatherFun4地址：01147A10
  15.   虚函数继承FatherFun1地址：01147A14
  16.   虚函数继承FatherFun2地址：01147A18
  17.   虚函数继承FatherFun2地址：01147A1C
  18.   虚函数sonFun1地址：01147A20
  19.   虚函数sonFun2地址：01147A24
  20.   虚函数sonFun3地址：01147A28
  21.   虚函数SonGetFatherFun4 diffrent param地址：01147A2C
  22.   **SonGetFatherFun4**
  23.   FatherFun1
  24.   FatherFun2
  25.   FatherFun3
  26.   SonFun1
  27.   SonFun2
  28.   SonFun3
  29.   SonGetFatherFun4 diffrent param

我们可以清楚的看到，位于子类最后函数重写的FatherFun4被放在了本该继承的父类FatherFun4位置上（先输出的是SonGetFatherFun4），而函数重定义则没有发生改变。

由此可以得出结论：

（1）覆盖的FatherFun4函数被放到了虚函数表中原父类虚函数的位置

（2）没有被覆盖的函数没有变化

在这里插入图片描述

6.子类指针指向父类

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <iostream>
  4.  
  5. using namespace std;
  6.  
  7. class Father
  8. {
  9. 	virtual void FatherFun1() {cout << "FatherFun1" <<endl;}
  10. 	virtual void FatherFun2() {cout << "FatherFun2" <<endl;}
  11. 	virtual void FatherFun3() {cout << "FatherFun3" <<endl;}
  12. };
  13.  
  14. class Son : public Father
  15. {
  16. 	virtual void SonFun1() {cout << "SonFun1" <<endl;}
  17. 	virtual void SonFun2() {cout << "SonFun2" <<endl;}
  18. 	virtual void SonFun3() {cout << "SonFun3" <<endl;}
  19. };
  20.  
  21. #if 0
  22. class Test
  23. {
  24. 	 void TestFun1() {cout << "TestFun1" <<endl;}
  25. 	 void TestFun2() {cout << "TestFun2" <<endl;}
  26. 	 void TestFun3() {cout << "TestFun3" <<endl;}
  27. };
  28. #endif
  29.  
  30. typedef void (*Fun)(void);
  31. typedef void (*FunParam)(int);
  32.  
  33. int main()
  34. {
  35. 	cout << "----------------测试父类------------------" << endl;
  36. 	Father father;
  37. 	cout << "类对象地址：" << &father << endl;
  38. 	cout << "虚函数表地址: " << (int*)*(int*)&father << endl;
  39. 	cout << "虚函数FatherFun1地址：" <<(int*)*(int*)&father << endl;
  40. 	cout << "虚函数FatherFun1地址：" <<(int*)*(int*)&father + 1 << endl;
  41. 	cout << "虚函数FatherFun2地址：" <<(int*)*(int*)&father + 2 << endl;
  42.  
  43. 	Fun fun = (Fun)*(int*)*(int*)&father;
  44. 	fun();
  45. 	fun = (Fun)*((int*)*(int*)(&father) + 1);
  46. 	fun();
  47. 	fun = (Fun)*((int*)*(int*)(&father) + 2);
  48. 	fun();
  49.  
  50.  
  51. 	cout << "----------------测试子类------------------" << endl;
  52. 	Son son;
  53. 	cout << "类对象地址：" << &son << endl;
  54. 	cout << "虚函数表地址: " << (int*)*(int*)&son << endl;
  55. 	cout << "虚函数继承FatherFun1地址：" <<(int*)*(int*)&son << endl;
  56. 	cout << "虚函数继承FatherFun2地址：" <<(int*)*(int*)&son + 1 << endl;
  57. 	cout << "虚函数继承FatherFun3地址：" <<(int*)*(int*)&son + 2 << endl;
  58. 	cout << "虚函数sonFun1地址：" <<(int*)*(int*)&son + 3 << endl;
  59. 	cout << "虚函数sonFun2地址：" <<(int*)*(int*)&son + 4 << endl;
  60. 	cout << "虚函数sonFun3地址：" <<(int*)*(int*)&son + 5 << endl;
  61. 	fun = (Fun)*(int*)*(int*)&son;
  62. 	fun();
  63. 	fun = (Fun)*((int*)*(int*)(&son) + 1);
  64. 	fun();
  65. 	fun = (Fun)*((int*)*(int*)(&son) + 2);
  66. 	fun();
  67. 	fun = (Fun)*((int*)*(int*)(&son) + 3);
  68. 	fun();
  69. 	fun = (Fun)*((int*)*(int*)(&son) + 4);
  70. 	fun();
  71. 	fun = (Fun)*((int*)*(int*)(&son) + 5);
  72. 	fun();
  73.  
  74. 	cout << "----------------测试父类指针指向子类------------------" << endl;
  75. 	Father* pointSon = new Son;
  76. 	cout << "类对象地址：" << pointSon << endl;
  77. 	cout << "虚函数表地址: " << (int*)*(int*)pointSon << endl;
  78. 	cout << "虚函数继承FatherFun1地址：" <<(int*)*(int*)pointSon << endl;
  79. 	cout << "虚函数继承FatherFun2地址：" <<(int*)*(int*)pointSon + 1 << endl;
  80. 	cout << "虚函数继承FatherFun3地址：" <<(int*)*(int*)pointSon + 2 << endl;
  81. 	cout << "虚函数sonFun1地址：" <<(int*)*(int*)pointSon + 3 << endl;
  82. 	cout << "虚函数sonFun2地址：" <<(int*)*(int*)pointSon + 4 << endl;
  83. 	cout << "虚函数sonFun3地址：" <<(int*)*(int*)pointSon + 5 << endl;
  84. 	fun = (Fun)*(int*)*(int*)pointSon;
  85. 	fun();
  86. 	fun = (Fun)*((int*)*(int*)(pointSon) + 1);
  87. 	fun();
  88. 	fun = (Fun)*((int*)*(int*)(pointSon) + 2);
  89. 	fun();
  90. 	fun = (Fun)*((int*)*(int*)(pointSon) + 3);
  91. 	fun();
  92. 	fun = (Fun)*((int*)*(int*)(pointSon) + 4);
  93. 	fun();
  94. 	fun = (Fun)*((int*)*(int*)(pointSon) + 5);
  95. 	fun();
  96.  
  97. 	system("pause");
  98. }

实际上父类指针指向子类，调用的是子类的虚函数表。

以下为输出：

----------------测试父类------------------
类对象地址：0029FDD0
虚函数表地址: 000F89BC
虚函数FatherFun1地址：000F89BC
虚函数FatherFun1地址：000F89C0
虚函数FatherFun2地址：000F89C4
FatherFun1
FatherFun2
FatherFun3
----------------测试子类------------------
类对象地址：0029FDB8
虚函数表地址: 000F8A00
虚函数继承FatherFun1地址：000F8A00
虚函数继承FatherFun2地址：000F8A04
虚函数继承FatherFun3地址：000F8A08
虚函数sonFun1地址：000F8A0C
虚函数sonFun2地址：000F8A10
虚函数sonFun3地址：000F8A14
FatherFun1
FatherFun2
FatherFun3
SonFun1
SonFun2
SonFun3
----------------测试父类指针指向子类------------------
类对象地址：003B55D8
虚函数表地址: 000F8A00
虚函数继承FatherFun1地址：000F8A00
虚函数继承FatherFun2地址：000F8A04
虚函数继承FatherFun3地址：000F8A08
虚函数sonFun1地址：000F8A0C
虚函数sonFun2地址：000F8A10
虚函数sonFun3地址：000F8A14
FatherFun1
FatherFun2
FatherFun3
SonFun1
SonFun2
SonFun3
请按任意键继续. . .

由虚函数表地址我们就可以看到，父类指针指向子类的时候，其虚函数表地址和子类虚函数表地址是一样的。由此，第五点确认

7.子类重写父类虚函数，并子类指针指向父类

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <iostream>
  4.  
  5. using namespace std;
  6.  
  7. class Father
  8. {
  9. 	virtual void FatherFun4() {cout << "FatherFun4" <<endl;}
  10. 	virtual void FatherFun1() {cout << "FatherFun1" <<endl;}
  11. 	virtual void FatherFun2() {cout << "FatherFun2" <<endl;}
  12. 	virtual void FatherFun3() {cout << "FatherFun3" <<endl;}
  13. };
  14.  
  15. class Son : public Father
  16. {
  17. 	virtual void SonFun1() {cout << "SonFun1" <<endl;}
  18. 	virtual void SonFun2() {cout << "SonFun2" <<endl;}
  19. 	virtual void SonFun3() {cout << "SonFun3" <<endl;}
  20. 	virtual void FatherFun4() {cout << "SonGetFatherFun4" <<endl;}
  21. };
  22.  
  23. #if 0
  24. class Test
  25. {
  26. 	 void TestFun1() {cout << "TestFun1" <<endl;}
  27. 	 void TestFun2() {cout << "TestFun2" <<endl;}
  28. 	 void TestFun3() {cout << "TestFun3" <<endl;}
  29. };
  30. #endif
  31.  
  32. typedef void (*Fun)(void);
  33. typedef void (*FunParam)(int);
  34.  
  35. int main()
  36. {
  37. 	cout << "----------------测试父类------------------" << endl;
  38. 	Father father;
  39. 	cout << "类对象地址：" << &father << endl;
  40. 	cout << "虚函数表地址: " << (int*)*(int*)&father << endl;
  41. 	cout << "虚函数FatherFun4地址：" <<(int*)*(int*)&father << endl;
  42. 	cout << "虚函数FatherFun1地址：" <<(int*)*(int*)&father + 1 << endl;
  43. 	cout << "虚函数FatherFun2地址：" <<(int*)*(int*)&father + 2 << endl;
  44. 	cout << "虚函数FatherFun3地址：" <<(int*)*(int*)&father + 3 << endl;
  45.  
  46. 	Fun fun = (Fun)*(int*)*(int*)&father;
  47. 	fun();
  48. 	fun = (Fun)*((int*)*(int*)(&father) + 1);
  49. 	fun();
  50. 	fun = (Fun)*((int*)*(int*)(&father) + 2);
  51. 	fun();
  52. 	fun = (Fun)*((int*)*(int*)(&father) + 3);
  53. 	fun();
  54.  
  55. 	cout << "----------------测试子类------------------" << endl;
  56. 	Son son;
  57. 	cout << "类对象地址：" << &son << endl;
  58. 	cout << "虚函数表地址: " << (int*)*(int*)&son << endl;
  59. 	cout << "虚函数继承FatherFun4地址：" <<(int*)*(int*)&son << endl;
  60. 	cout << "虚函数继承FatherFun1地址：" <<(int*)*(int*)&son + 1 << endl;
  61. 	cout << "虚函数继承FatherFun2地址：" <<(int*)*(int*)&son + 2 << endl;
  62. 	cout << "虚函数继承FatherFun3地址：" <<(int*)*(int*)&son + 3 << endl;
  63. 	cout << "虚函数sonFun1地址：" <<(int*)*(int*)&son + 4 << endl;
  64. 	cout << "虚函数sonFun2地址：" <<(int*)*(int*)&son + 5 << endl;
  65. 	cout << "虚函数sonFun3地址：" <<(int*)*(int*)&son + 6 << endl;
  66. 	fun = (Fun)*(int*)*(int*)&son;
  67. 	fun();
  68. 	fun = (Fun)*((int*)*(int*)(&son) + 1);
  69. 	fun();
  70. 	fun = (Fun)*((int*)*(int*)(&son) + 2);
  71. 	fun();
  72. 	fun = (Fun)*((int*)*(int*)(&son) + 3);
  73. 	fun();
  74. 	fun = (Fun)*((int*)*(int*)(&son) + 4);
  75. 	fun();
  76. 	fun = (Fun)*((int*)*(int*)(&son) + 5);
  77. 	fun();
  78. 	fun = (Fun)*((int*)*(int*)(&son) + 6);
  79. 	fun();
  80.  
  81.  
  82. 	cout << "----------------测试父类指针指向子类------------------" << endl;
  83. 	Father* pointSon = new Son;
  84. 	cout << "类对象地址：" << pointSon << endl;
  85. 	cout << "虚函数表地址: " << (int*)*(int*)pointSon << endl;
  86. 	cout << "虚函数继承FatherFun1地址：" <<(int*)*(int*)pointSon << endl;
  87. 	cout << "虚函数继承FatherFun2地址：" <<(int*)*(int*)pointSon + 1 << endl;
  88. 	cout << "虚函数继承FatherFun3地址：" <<(int*)*(int*)pointSon + 2 << endl;
  89. 	cout << "虚函数sonFun1地址：" <<(int*)*(int*)pointSon + 3 << endl;
  90. 	cout << "虚函数sonFun2地址：" <<(int*)*(int*)pointSon + 4 << endl;
  91. 	cout << "虚函数sonFun3地址：" <<(int*)*(int*)pointSon + 5 << endl;
  92. 	fun = (Fun)*(int*)*(int*)pointSon;
  93. 	fun();
  94. 	fun = (Fun)*((int*)*(int*)(pointSon) + 1);
  95. 	fun();
  96. 	fun = (Fun)*((int*)*(int*)(pointSon) + 2);
  97. 	fun();
  98. 	fun = (Fun)*((int*)*(int*)(pointSon) + 3);
  99. 	fun();
  100. 	fun = (Fun)*((int*)*(int*)(pointSon) + 4);
  101. 	fun();
  102. 	fun = (Fun)*((int*)*(int*)(pointSon) + 5);
  103. 	fun();
  104. 	fun = (Fun)*((int*)*(int*)(pointSon) + 6);
  105. 	fun();
  106.  
  107. 	system("pause");
  108. }

直接看输出结果：

  1.   	----------------测试父类------------------
  2.   类对象地址：0034F788
  3.   虚函数表地址: 000B8A14
  4.   虚函数FatherFun4地址：000B8A14
  5.   虚函数FatherFun1地址：000B8A18
  6.   虚函数FatherFun2地址：000B8A1C
  7.   虚函数FatherFun3地址：000B8A20
  8.   FatherFun4
  9.   FatherFun1
  10.   FatherFun2
  11.   FatherFun3
  12.   ----------------测试子类------------------
  13.   类对象地址：0034F770
  14.   虚函数表地址: 000B8A6C
  15.   虚函数继承FatherFun4地址：000B8A6C
  16.   虚函数继承FatherFun1地址：000B8A70
  17.   虚函数继承FatherFun2地址：000B8A74
  18.   虚函数继承FatherFun3地址：000B8A78
  19.   虚函数sonFun1地址：000B8A7C
  20.   虚函数sonFun2地址：000B8A80
  21.   虚函数sonFun3地址：000B8A84
  22.   SonGetFatherFun4
  23.   FatherFun1
  24.   FatherFun2
  25.   FatherFun3
  26.   SonFun1
  27.   SonFun2
  28.   SonFun3
  29.   ----------------测试父类指针指向子类------------------
  30.   类对象地址：005855D8
  31.   虚函数表地址: 000B8A6C
  32.   虚函数继承FatherFun1地址：000B8A6C
  33.   虚函数继承FatherFun2地址：000B8A70
  34.   虚函数继承FatherFun3地址：000B8A74
  35.   虚函数sonFun1地址：000B8A78
  36.   虚函数sonFun2地址：000B8A7C
  37.   虚函数sonFun3地址：000B8A80
  38.   SonGetFatherFun4
  39.   FatherFun1
  40.   FatherFun2
  41.   FatherFun3
  42.   SonFun1
  43.   SonFun2
  44.   SonFun3
  45.   请按任意键继续. . .

实际上和第六点结果是一样的

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

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

  

闽ICP备14008679号