【C++深度剖析教程29】C++对象模型分析下

加qq1126137994，微信：liu1126137994 一起学习更多技术！！！

今天来继续学习C++对象模型！

1. 在C++编译器内部，类可以理解为结构体
2. 子类是由父类成员叠加子类新成员得到的
   

下面来写一个程序分析C++的继承类的模型：

#include <iostream>
#include <string>

using namespace std;

class Demo
{
protected:
    int mi;
    int mj;
public:
    virtual void print()
    {
        cout << "mi = " << mi << ", "
             << "mj = " << mj << endl;
    }
};

class Derived : public Demo
{
    int mk;
public:
    Derived(int i, int j, int k)
    {
        mi = i;
        mj = j;
        mk = k;
    }

    void print()
    {
        cout << "mi = " << mi << ", "
             << "mj = " << mj << ", "
             << "mk = " << mk << endl;
    }
};

struct Test
{
    //void* p; //模拟C++中的指向虚函数表的指针
    int mi;
    int mj;
    int mk;
};

int main()
{
    cout << "sizeof(Demo) = " << sizeof(Demo) << endl; // 加上虚函数virtual后，大小变为12
                                                       //因为编译器发现是虚函数的时候，会自动
                                                       //生成一个指针指向虚函数表
    cout << "sizeof(Derived) = " << sizeof(Derived) << endl;  

    Derived d(1, 2, 3);
    Test* p = reinterpret_cast<Test*>(&d); //p与d类型不同，需要用reinterpret_cast进行类型转换

    cout << "Before changing ..." << endl;

    d.print();

    p->mi = 10;  //p作为外界的结构体竟然可以访问d的变量，说明p的内存结构与d的相同
    p->mj = 20;
    p->mk = 30;

    cout << "After changing ..." << endl;

    d.print();

    return 0;
}

（注意以上程序用编译器是gcc编译器，所以结构体的字节对齐是4字节默认）

运行结果为：

那么久引出了问题：C++多态的实现原理是什么？

C++多态的实现原理：

1. 当类中声明一个虚函数时，编译器会在类中生成一个虚函数表
2. 虚函数表是一个存储成员函数地址的数据结构
3. 虚函数表是由编译器自动生成与维护的
4. virtual成员函数，会被编译器放进虚函数表中
5. 存在虚函数时，每个对象中都有一个指向虚函数表的指针

如下图：
virtual成员函数，会被编译器放进虚函数表中

存在虚函数时，每个对象中都有一个指向虚函数表的指针

我们会发现，虚函数的调用过程比普通函数的调用过程复杂，所以虚函数的执行效率低于普通成员函数：

下面给出用C语言实现的C++中的虚函数表的相关概念：
51-2.h为：

#ifndef _51_2_H_
#define _51_2_H_

typedef void Demo;
typedef void Derived;

Demo* Demo_Create(int i, int j);
int Demo_GetI(Demo* pThis);
int Demo_GetJ(Demo* pThis);
int Demo_Add(Demo* pThis, int value);
void Demo_Free(Demo* pThis);

Derived* Derived_Create(int i, int j, int k);
int Derived_GetK(Derived* pThis);
int Derived_Add(Derived* pThis, int value);

#endif

51-2.c为：

#include "51-2.h"
#include "malloc.h"

static int Demo_Virtual_Add(Demo* pThis, int value);
static int Derived_Virtual_Add(Demo* pThis, int value);

struct VTable     // 2. 定义虚函数表数据结构
{
    int (*pAdd)(void*, int);   // 3. 虚函数表里面存储什么？？？
};

struct ClassDemo
{
    struct VTable* vptr;     // 1. 定义虚函数表指针  ==》 虚函数表指针类型？？？
    int mi;
    int mj;
};

struct ClassDerived
{
    struct ClassDemo d;
    int mk;
};

static struct VTable g_Demo_vtbl =   //static关键字将该虚函数表隐藏在当前文件内，外部不可见
                                    //类似于C++中虚函数表是自动生成的，外部不可见。
{
    Demo_Virtual_Add
};

static struct VTable g_Derived_vtbl = 
{
    Derived_Virtual_Add
};

Demo* Demo_Create(int i, int j)
{
    struct ClassDemo* ret = (struct ClassDemo*)malloc(sizeof(struct ClassDemo)); 

    if( ret != NULL )
    {
        ret->vptr = &g_Demo_vtbl;   // 4. 关联对象和虚函数表
        ret->mi = i;
        ret->mj = j;
    }

    return ret;
}

int Demo_GetI(Demo* pThis)
{
     struct ClassDemo* obj = (struct ClassDemo*)pThis;    

     return obj->mi;
}

int Demo_GetJ(Demo* pThis)
{
    struct ClassDemo* obj = (struct ClassDemo*)pThis;

    return obj->mj;
}

// 6. 定义虚函数表中指针所指向的具体函数
static int Demo_Virtual_Add(Demo* pThis, int value)
{
    struct ClassDemo* obj = (struct ClassDemo*)pThis;

    return obj->mi + obj->mj + value;
}


// 5. 分析具体的虚函数！！！！
int Demo_Add(Demo* pThis, int value)
{

    struct ClassDemo* obj = (struct ClassDemo*)pThis;

    return obj->vptr->pAdd(pThis, value);
}

void Demo_Free(Demo* pThis)
{
    free(pThis);
}

Derived* Derived_Create(int i, int j, int k) //等同于构造函数
{
    struct ClassDerived* ret = (struct ClassDerived*)malloc(sizeof(struct ClassDerived));

    if( ret != NULL )
    {
        ret->d.vptr = &g_Derived_vtbl;
        ret->d.mi = i;
        ret->d.mj = j;
        ret->mk = k;
    }

    return ret;
}

int Derived_GetK(Derived* pThis)
{
    struct ClassDerived* obj = (struct ClassDerived*)pThis;

    return obj->mk;
}

static int Derived_Virtual_Add(Demo* pThis, int value)
{
    struct ClassDerived* obj = (struct ClassDerived*)pThis; 

    return obj->mk + value;
}

int Derived_Add(Derived* pThis, int value)
{   
    struct ClassDerived* obj = (struct ClassDerived*)pThis;

    return obj->d.vptr->pAdd(pThis, value);
}

main.c为：

#include "stdio.h"
#include "51-2.h"

void run(Demo* p, int v)
{
    int r = Demo_Add(p, v);

    printf("r = %d\n", r);
}

int main()
{
    Demo* pb = Demo_Create(1, 2);
    Derived* pd = Derived_Create(1, 22, 333);

    printf("pb->add(3) = %d\n", Demo_Add(pb, 3));
    printf("pd->add(3) = %d\n", Derived_Add(pd, 3));

    run(pb, 3);
    run(pd, 3);

    Demo_Free(pb);
    Demo_Free(pd);

    return 0;
}

总结：

1. 继承的本质就是父子间成员变量的叠加
2. C++中的多态是通过虚函数表实现的
3. 虚函数表，是由编译器自动生成与维护的
4. 虚函数的调用效率低于普通成员函数的调用效率

想获得各种学习资源以及交流学习的加我：
qq：1126137994
微信：liu1126137994
可以共同交流关于嵌入式Linux，操作系统，C++语言，C语言，数据结构与算法等技术问题。