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

1.概述

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

2.动手前的预备知识点

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

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

• 代码 test4.c

#include <stdint.h>
#include <string.h>
#include <malloc.h>
#include <stdio.h>

int32_t g_int = 10;

int main()
{
    //申请5个字节大小的堆内存
    void * p = malloc(5);
    //每个字节的值设置为90
    memset(p, 90, 5);        
    
    //声明一个char指针pc指向分配的内存的起始地址
    char * pc = (char *)p;
    //声明一个int32_t指针pint指向分配的内存的起始地址
    int32_t * pint = (int32_t *)p;
    
    //从起始地址开始取1个字节的内存去解析成char变量
    if (*pc == 90) 
    {
        printf("char yes\n");
    }
    
    //从起始地址开始取4个字节的内存去解析成int32_t变量
    if (*pint == 90 + (90 << 8) + (90 << 16) + (90 << 24))
    {
        printf("int yes\n");
    }
    
    return 0;
}

• 运行结果

• 详细图解

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

• 至少应该包含函数符号，全局变量（如果文件中有定义全局变量）。

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

• 命令执行结果

3. c++静态多态

3.1实际编码操作

• 代码test5.cpp

#include <iostream>
using namespace std;

void fun1()
{
    cout << "fun1 call" << endl;
}

void fun1(int a)
{
    cout << "fun1 a call" << endl;
}

int main()
{
    fun1();
    fun1(10);
    return 0;
}

• 运行结果

3.2 实现的原理

• 通过重载（overload）的特性来实现，在编译阶段就决定要调用那个函数，故称为静态多态。

• c++编译器在编译代码时，会对函数符号重签名（c编译器不会），当c++编译器遇到重载调用时则直接调用重签名后的函数，使用nm命令查看可执行文件的符号我们看到两个被重签名的符号

3.3以c的视角理解

#include <stdio.h>

void _Z4fun1v()
{
    printf("fun1 call\n");
}

void _Z4fun1i(int a)
{
    printf("fun1 a call\n");
}

int main()
{
    _Z4fun1v(); //对应之前的void fun1();
    _Z4fun1i(10); //对应之前的void fun1(int a);
    return 0;
}

4.c++动态多态

4.1实际编码操作

• 代码test6.cpp

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void sleep()
    {
        cout << "Base sleep" << endl;
    }
    virtual void eat()
    {
        cout << "Base eat" << endl;
    }
    virtual void run()
    {
        cout << "Base run" << endl;
    }
};

class Animal : public Base
{
public:
    size_t age;
    
    void sleep()
    {
        cout << "Animal sleep" << endl;
    }
    void eat()
    {
        cout << "Animal eat" << endl;
    }
    void run()
    {
        cout << "Animal run" << endl;
    }
};

/*
    定义一个函数指针类型，类型为 void () (Animal * )；
    用于指向虚函数sleep，eat，run；
    这里之所以多出一个Animal * 参数是因为c++类的非静态成员函数，
    编译器会默认在参数列表开头加入指向类指针的参数
 */
typedef void (* pFun)(Animal * animal);

int main()
{
    Animal dargon;
    Animal dog;
    
    Base * pBase = &dargon;
    Base & pRe = dog;
    
    //通过基类的指针指向派生类对象来实现动态多态
    pBase->sleep();
    //通过基类的引用指向派生类对象来实现动态多态
    pRe.sleep();
    
    /*
        取出Animal的虚表指针.
        (size_t *)&dargon -> dargon起始地址转换为size_t *
        *(size_t *)&dargon -> dargon起始地址开始取sizeof(size_t)个字节解析成size_t(虚表指针的值)
        (size_t *)*(size_t *)&dargon -> 把这个值转换成size_t *类型
    
        ps: size_t在32位机是4个字节，在64位机是8个字节，指针变量的大小和size_t的大小是一致的。
     */
    size_t * vptable_dargon = (size_t *)*(size_t *)&dargon;
    size_t * vptable_dog = (size_t *)*(size_t *)&dog;
    
    cout << "size_t size = " << sizeof(size_t) << endl;
    
    //一个类公用一个虚表指针
    if (vptable_dog == vptable_dargon)
    {
        cout << "vptable value is equal" << endl;
    }
    
    //遍历虚表指针
    while (*vptable_dargon)
    {
        //取出每个虚表函数
        pFun fun = (pFun)(*vptable_dargon);
        //调用每个虚表函数
        fun(&dargon);
        vptable_dargon++;
    }
    
    return 0;
}

• 运行结果

4.2 实现原理

• 通过c++的重写（override）的特性来实现，只有在运行时才知道真正调用是什么那个函数，故称为动态多态。

• c++为有虚函数的每个类添加了一个虚函数表（类的静态变量），并在每个类对象的起始地址处嵌入一个虚表指针指向它，再通过这个虚表指针来实现运行时的多态。

4.3 以c的视角理解

• 代码test7.cpp

#include <stdio.h>
#include <malloc.h>
#include <string.h>

//全局静态的虚表指针，模拟类的静态虚表指针
static size_t * pBaseVptable = NULL;
static size_t * pAnimalVptable = NULL;

struct Base
{
    size_t * vptable;    //模拟虚表指针
};

struct Animal
{
    struct Base base;    //模拟Animal继承Base
    size_t age;
};

typedef void (* pFun)(Base * pBase);

void baseSleep(Base * pBase)
{
    printf("Base sleep\n");
}
void baseEat(Base * pBase)
{
    printf("Base eat\n");
}
void baseRun(Base * pBase)
{
    printf("Base run\n");
}

void animalSleep(Animal * pAnimal)
{
    printf("Animal age[%d] sleep\n", pAnimal->age);
}
void animalEat(Animal * pAnimal)
{
    printf("Animal age[%d] eat\n", pAnimal->age);
}
void animalRun(Animal * pAnimal)
{
    printf("Animal age[%d] run\n", pAnimal->age);
}

//Base结构体初始化
void baseInit(Base * pBase)
{
    pBase->vptable = pBaseVptable;
}

//Animal结构体初始化
void AnimalInit(Animal * pAnimal)
{
    pAnimal->base.vptable = pAnimalVptable;
}

/*
    虚表指针初始化
 */
void vptableInit()
{
    pBaseVptable = (size_t *)malloc(sizeof(size_t) * 4);
    pAnimalVptable = (size_t *)malloc(sizeof(size_t) * 4);
    
    memset(pBaseVptable, 0x0, sizeof(size_t) * 4);
    memset(pAnimalVptable, 0x0, sizeof(size_t) * 4);
    
    //Base类全局虚表初始化
    pBaseVptable[0] = (size_t)&baseSleep;
    pBaseVptable[1] = (size_t)&baseEat;
    pBaseVptable[2] = (size_t)&baseRun;
    
    //Animal类全局虚表初始化
    pAnimalVptable[0] = (size_t)&animalSleep;
    pAnimalVptable[1] = (size_t)&animalEat;
    pAnimalVptable[2] = (size_t)&animalRun;
}

void callVirtualFun(Base * pBase, int index)
{
    pFun fun = (pFun)pBase->vptable[index];
    fun(pBase);
}

int main()
{
    //虚表初始化
    vptableInit();
    Base * pBase = NULL;
    Animal * pAnimal = (Animal *)malloc(sizeof(Animal));
    
    //模拟对象初始化
    AnimalInit(pAnimal);
    pAnimal->age = 99;
    
    //模拟基类指针指向派生类
    pBase = (Base *)pAnimal;
    
    //模拟调用虚函数
    callVirtualFun(pBase, 0);
    callVirtualFun(pBase, 1);
    callVirtualFun(pBase, 2);
    
    return 0;
}

• 运行结果

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)