C++ 对象模型分析（下）

继承对象模型

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

class Derived : public Demo  
{
    int mk;
};

图片.png

编程实验1 ：继承对象模型初探

#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;  // 指针放在一开始的地方,代表虚函数指针的位置
    int mi;
    int mj;
    int mk;
};

int main()
{
    cout << "sizeof(Demo) = " << sizeof(Demo) << endl;        // 12字节  
    cout << "sizeof(Derived) = " << sizeof(Derived) << endl;  // 16字节
    
    Derived d(1, 2, 3);
    Test* p = reinterpret_cast<Test*>(&d);
    
    cout << "Before changing ..." << endl;
    
    d.print();
    
    p->mi = 10;
    p->mj = 20;
    p->mk = 30;
    
    cout << "After changing ..." << endl;
    
    d.print();
    
    return 0;
}

编译环境：Linux 64位
输出：   
sizeof(Demo) = 16
sizeof(Derived) = 20
sizeof(struct Test) = 20
Before changing ...
mi = 1, mj = 2, mk = 3
After changing ...
mi = 10, mj = 20, mk = 30

类里面有虚函数，编译的时候会在类里面生成一个指针
强行塞入一个指向虚函数表的指针！！放在最开始的四个字节的地方,放在其它地方内存排布是错位的

多态对象模型

C ++ 多态的实现原理

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

class Demo
{
    int mi,mj;
public:
    virtual int add(int value)
    {
        return mi + mj + value;
    }
};

图片.png

class Derived : public Demo
{
    int mk;
public:
    virtual int add(int value)
    {
        return mk + vakue;
    }
};

图片.png

void run(Demo *p, int v)
{
    p->add(v);
}

编译过程
编译器确认 add() 是否为虚函数？

Yes：编译器在对象 VPTR 所指向的虚函数表中查找 add() 地址
No : 编译器直接可以确定被调用成员函数的地址

图片.png
由图分析
调用效率：虚函数 < 普通成员函数
虚函数是通过牺牲效率来实现多态的，所以在写代码的时候需要考虑成员函数是否需要成为虚函数

虚函数的调用过程

通过P指针找到具体的对象(1)，然后在找到对象里面的虚函数表指针(2)，在通过虚函数指针找到虚函数表，在虚函数表内通过查找找到对应的地址(3),3次寻地址，效率不高

编程实验2: C 方式实现多态

思路

定义虚函数表指针

那么虚函数表指针类型是什么？虚函数表也是一种数据结构

定义虚函数表数据结构体，然后创建对应的虚函数表
虚函数表里面存储什么?

指向程序函数的指针

关联对象和虚函数表
分析具体的虚函数
定义虚函数表中指针指向的具体函数

// .h 文件  

#ifndef __51_1_H__
#define __51_1_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

// .c 文件  

#include <stdio.h>
#include <stdlib.h>

#include "51-1.h" 

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


struct VTable
{
    int (* pAdd)(void *pThis, int value);
};

struct class_Demo
{
    struct VTable *vptr;
    int mi;
    int mj;
};

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

static struct VTable g_Demo_vtbl = 
{
    Demo_Virtual_Add
};   

static struct VTable g_Derived_vtbl = 
{
    Derived_Virtual_Add
};


Demo* Demo_Create(int i, int j)
{
    struct class_Demo *ret = (struct class_Demo *)malloc(sizeof(struct class_Demo));
    
    if(ret != NULL)
    {
        //ret->vptr.pAdd = Demo_Virtual_Add；
        ret->vptr = &g_Demo_vtbl;
        ret->mi = i;
        ret->mj = j;
    }
    
    return ret;    
}

int Demo_GetI(Demo* pThis)
{
    struct class_Demo *obj = (struct class_Demo *)(pThis);
    
    return obj->mi;
}

int Demo_GetJ(Demo* pThis)
{
    struct class_Demo *obj = (struct class_Demo *)(pThis);
    
    return obj->mj;
    
}

static int Demo_Virtual_Add(Demo *pThis, int value)
{
    struct class_Demo* obj = (struct class_Demo*)pThis;
    
    return obj->mi + obj->mj + value;
}

 int Demo_Add(Demo* pThis, int value)
{
    struct class_Demo *obj = (struct class_Demo *)(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;
}

小结

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

补充说明

面向对象程序最关键的地方在于必须能表现三大特征：封装，继承，多态

封装

封装是类中的敏感数据在外界是不能访问的

继承

继承指的是可以对已经存在的类进行代码复用，并使得类之间存在父子关系

多态

多态指的是相同的语句可以产生不同的调用结果

如果 C 语言完成面向对象的程序，必须要实现上面 3 个特征，否则只能算是基于对象的程序(程序中能够看到对象的影子，但是不完全具备面向对象的3大特性)

实现方式

封装

通过 void * 指针保证具体的结构体成员是不能被外界访问的，以此模拟C++ 中 private 和 protected ，在头文件定义如下语句

typedef void Parent;
typedef void Derived;

Parent 和 Derived 的本质依旧还是 void ,所以用 Parent 指针和Derived 指针指向具体对象时，无法访问对象中的成员变量，达到外界无法访问类中的私有成员的封装效果

继承

继承的本质还是父类成员和子类成员的叠加，在 C 中可以直接考虑结构体成员的叠加即可

struct class_Demo
{
    struct VTable *vptr;
    int mi;
    int mj;
};

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

可以说 struct ClassDerived 继承 struct class_Demo

多态

多态在 C++ 中的实现本质还是通过虚函数表完成的，而虚函数表时通过编译器自主产生和维护的数据结构，如何使用C自定义虚函数表？通过结构体变量模拟C++中的虚函数表时比较好的一种选择

struct VTable
{
    int (* pAdd)(void *pThis, int value);
};

有了类型之后就可以定义实际的虚函数表，在C语言中用具有文件作用域的全局变量表示实际的虚函数是最合适的，每个对象中都拥有一个指向虚函数表的指针，所有父类对象指针指向 g_Demo_vtbl, 所有子类对象指向 g_Derived_vtbl. 实际调用虚函数的过程就是通过虚函数表中对应指针来完成的。

C++ 对象模型分析（下）