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

最新推荐文章于 2022-05-28 08:56:15 发布

always@(posedge)

最新推荐文章于 2022-05-28 08:56:15 发布

阅读量146

点赞数

分类专栏： C++ 文章标签： c++ 多态

本文链接：https://blog.csdn.net/zhabin0607/article/details/105470715

版权

C++ 专栏收录该内容

48 篇文章 2 订阅

订阅专栏

第51课 - C++ 对象模型分析（下）

继承对象模型

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

class Derived : public Demo  
{
    int mk;
};

在这里插入图片描述

编程实验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;
    }
};

在这里插入图片描述

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

在这里插入图片描述

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

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

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

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

虚函数的调用过程

通过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. 实际调用虚函数的过程就是通过虚函数表中对应指针来完成的。

always@(posedge)

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++ 对象模型分析（下）

第51课 - C++ 对象模型分析（下）继承对象模型在 C++ 编译器的内部类可以理解为结构体子类是由父类成员函数叠加子类新成员得到的class Derived : public Demo { int mk;};编程实验1 ：继承对象模型初探#include <iostream>#include <string>using names...
复制链接

扫一扫

专栏目录