首页 > c/c++ > 以c的视角来理解c++的多态

以c的视角来理解c++的多态

2017年3月22日 540 人阅读 发表评论 阅读评论

1.概述

c++是一门混合型编程语言,即支持面向对象有支持面向过程,其中又以面向对象为主。c++的三大主要特性:“继承”,“封装”,“多态”中,又以“多态”最难以理解,本文将通过c的视角来诠释c++的多态。

2.动手前的预备知识点

2.1 你知道不同类型的指针意味着什么?

不同的指针类型,意味这对同一块内存起始地址的不同解析方式,下面我们举一个栗子。

  • 代码 test4.c
  1. #include <stdint.h>
  2. #include <string.h>
  3. #include <malloc.h>
  4. #include <stdio.h>
  5. int32_t g_int = 10;
  6. int main()
  7. {
  8. //申请5个字节大小的堆内存
  9. void * p = malloc(5);
  10. //每个字节的值设置为90
  11. memset(p, 90, 5);
  12. //声明一个char指针pc指向分配的内存的起始地址
  13. char * pc = (char *)p;
  14. //声明一个int32_t指针pint指向分配的内存的起始地址
  15. int32_t * pint = (int32_t *)p;
  16. //从起始地址开始取1个字节的内存去解析成char变量
  17. if (*pc == 90)
  18. {
  19. printf("char yes\n");
  20. }
  21. //从起始地址开始取4个字节的内存去解析成int32_t变量
  22. if (*pint == 90 + (90 << 8) + (90 << 16) + (90 << 24))
  23. {
  24. printf("int yes\n");
  25. }
  26. return 0;
  27. }
  • 运行结果
  • 详细图解

2.2 c文件编译成一个目标文件,目标文件里包含什么?

  • 至少应该包含函数符号,全局变量(如果文件中有定义全局变量)。
  • 通过gcc和nm命令我们可以看到用上面的测试代码生成的test4.o这个目标文件中包含有一个全局变量g_int,一个有定义的函数符号main,三个未定义的函数符号malloc,memset,puts。
  • 命令执行结果

3. c++静态多态

3.1实际编码操作

  • 代码test5.cpp
  1. #include <iostream>
  2. using namespace std;
  3. void fun1()
  4. {
  5. cout << "fun1 call" << endl;
  6. }
  7. void fun1(int a)
  8. {
  9. cout << "fun1 a call" << endl;
  10. }
  11. int main()
  12. {
  13. fun1();
  14. fun1(10);
  15. return 0;
  16. }
  • 运行结果

3.2 实现的原理

  • 通过重载(overload)的特性来实现,在编译阶段就决定要调用那个函数,故称为静态多态。
  • c++编译器在编译代码时,会对函数符号重签名(c编译器不会),当c++编译器遇到重载调用时则直接调用重签名后的函数,使用nm命令查看可执行文件的符号我们看到两个被重签名的符号

3.3以c的视角理解

  1. #include <stdio.h>
  2. void _Z4fun1v()
  3. {
  4. printf("fun1 call\n");
  5. }
  6. void _Z4fun1i(int a)
  7. {
  8. printf("fun1 a call\n");
  9. }
  10. int main()
  11. {
  12. _Z4fun1v(); //对应之前的void fun1();
  13. _Z4fun1i(10); //对应之前的void fun1(int a);
  14. return 0;
  15. }

4.c++动态多态

4.1实际编码操作

  • 代码test6.cpp
  1. #include <iostream>
  2. using namespace std;
  3. class Base
  4. {
  5. public:
  6. virtual void sleep()
  7. {
  8. cout << "Base sleep" << endl;
  9. }
  10. virtual void eat()
  11. {
  12. cout << "Base eat" << endl;
  13. }
  14. virtual void run()
  15. {
  16. cout << "Base run" << endl;
  17. }
  18. };
  19. class Animal : public Base
  20. {
  21. public:
  22. size_t age;
  23. void sleep()
  24. {
  25. cout << "Animal sleep" << endl;
  26. }
  27. void eat()
  28. {
  29. cout << "Animal eat" << endl;
  30. }
  31. void run()
  32. {
  33. cout << "Animal run" << endl;
  34. }
  35. };
  36. /*
  37. 定义一个函数指针类型,类型为 void () (Animal * );
  38. 用于指向虚函数sleep,eat,run;
  39. 这里之所以多出一个Animal * 参数是因为c++类的非静态成员函数,
  40. 编译器会默认在参数列表开头加入指向类指针的参数
  41. */
  42. typedef void (* pFun)(Animal * animal);
  43. int main()
  44. {
  45. Animal dargon;
  46. Animal dog;
  47. Base * pBase = &dargon;
  48. Base & pRe = dog;
  49. //通过基类的指针指向派生类对象来实现动态多态
  50. pBase->sleep();
  51. //通过基类的引用指向派生类对象来实现动态多态
  52. pRe.sleep();
  53. /*
  54. 取出Animal的虚表指针.
  55. (size_t *)&dargon -> dargon起始地址转换为size_t *
  56. *(size_t *)&dargon -> dargon起始地址开始取sizeof(size_t)个字节解析成size_t(虚表指针的值)
  57. (size_t *)*(size_t *)&dargon -> 把这个值转换成size_t *类型
  58. ps: size_t在32位机是4个字节,在64位机是8个字节,指针变量的大小和size_t的大小是一致的。
  59. */
  60. size_t * vptable_dargon = (size_t *)*(size_t *)&dargon;
  61. size_t * vptable_dog = (size_t *)*(size_t *)&dog;
  62. cout << "size_t size = " << sizeof(size_t) << endl;
  63. //一个类公用一个虚表指针
  64. if (vptable_dog == vptable_dargon)
  65. {
  66. cout << "vptable value is equal" << endl;
  67. }
  68. //遍历虚表指针
  69. while (*vptable_dargon)
  70. {
  71. //取出每个虚表函数
  72. pFun fun = (pFun)(*vptable_dargon);
  73. //调用每个虚表函数
  74. fun(&dargon);
  75. vptable_dargon++;
  76. }
  77. return 0;
  78. }
  • 运行结果

4.2 实现原理

  • 通过c++的重写(override)的特性来实现,只有在运行时才知道真正调用是什么那个函数,故称为动态多态。
  • c++为有虚函数的每个类添加了一个虚函数表(类的静态变量),并在每个类对象的起始地址处嵌入一个虚表指针指向它,再通过这个虚表指针来实现运行时的多态。

4.3 以c的视角理解

  • 代码test7.cpp
  1. #include <stdio.h>
  2. #include <malloc.h>
  3. #include <string.h>
  4. //全局静态的虚表指针,模拟类的静态虚表指针
  5. static size_t * pBaseVptable = NULL;
  6. static size_t * pAnimalVptable = NULL;
  7. struct Base
  8. {
  9. size_t * vptable; //模拟虚表指针
  10. };
  11. struct Animal
  12. {
  13. struct Base base; //模拟Animal继承Base
  14. size_t age;
  15. };
  16. typedef void (* pFun)(Base * pBase);
  17. void baseSleep(Base * pBase)
  18. {
  19. printf("Base sleep\n");
  20. }
  21. void baseEat(Base * pBase)
  22. {
  23. printf("Base eat\n");
  24. }
  25. void baseRun(Base * pBase)
  26. {
  27. printf("Base run\n");
  28. }
  29. void animalSleep(Animal * pAnimal)
  30. {
  31. printf("Animal age[%d] sleep\n", pAnimal->age);
  32. }
  33. void animalEat(Animal * pAnimal)
  34. {
  35. printf("Animal age[%d] eat\n", pAnimal->age);
  36. }
  37. void animalRun(Animal * pAnimal)
  38. {
  39. printf("Animal age[%d] run\n", pAnimal->age);
  40. }
  41. //Base结构体初始化
  42. void baseInit(Base * pBase)
  43. {
  44. pBase->vptable = pBaseVptable;
  45. }
  46. //Animal结构体初始化
  47. void AnimalInit(Animal * pAnimal)
  48. {
  49. pAnimal->base.vptable = pAnimalVptable;
  50. }
  51. /*
  52. 虚表指针初始化
  53. */
  54. void vptableInit()
  55. {
  56. pBaseVptable = (size_t *)malloc(sizeof(size_t) * 4);
  57. pAnimalVptable = (size_t *)malloc(sizeof(size_t) * 4);
  58. memset(pBaseVptable, 0x0, sizeof(size_t) * 4);
  59. memset(pAnimalVptable, 0x0, sizeof(size_t) * 4);
  60. //Base类全局虚表初始化
  61. pBaseVptable[0] = (size_t)&baseSleep;
  62. pBaseVptable[1] = (size_t)&baseEat;
  63. pBaseVptable[2] = (size_t)&baseRun;
  64. //Animal类全局虚表初始化
  65. pAnimalVptable[0] = (size_t)&animalSleep;
  66. pAnimalVptable[1] = (size_t)&animalEat;
  67. pAnimalVptable[2] = (size_t)&animalRun;
  68. }
  69. void callVirtualFun(Base * pBase, int index)
  70. {
  71. pFun fun = (pFun)pBase->vptable[index];
  72. fun(pBase);
  73. }
  74. int main()
  75. {
  76. //虚表初始化
  77. vptableInit();
  78. Base * pBase = NULL;
  79. Animal * pAnimal = (Animal *)malloc(sizeof(Animal));
  80. //模拟对象初始化
  81. AnimalInit(pAnimal);
  82. pAnimal->age = 99;
  83. //模拟基类指针指向派生类
  84. pBase = (Base *)pAnimal;
  85. //模拟调用虚函数
  86. callVirtualFun(pBase, 0);
  87. callVirtualFun(pBase, 1);
  88. callVirtualFun(pBase, 2);
  89. return 0;
  90. }
  • 运行结果

5.编译运行环境

  • 操作系统

    [root@iZ940zytujjZ ~]# uname -m -s
    Linux x86_64

  • 编译器

    [root@iZ940zytujjZ ~]# gcc –version
    gcc (GCC) 4.4.7 20120313 (Red Hat 4.4.7-4)
    [root@iZ940zytujjZ ~]# g++ –version
    g++ (GCC) 4.4.7 20120313 (Red Hat 4.4.7-4)

分类: c/c++ 标签:
  1. 本文目前尚无任何评论.
  1. 本文目前尚无任何 trackbacks 和 pingbacks.