C++ 虚函数表多重继承

上次研究的是单继承的情况，这次研究多重继承下的虚函数表的排列情况。

这次A，A1,A2,B这几个类的继承关系如下图：

测试代码如下：

#include<iostream>

using namespace std;

class  A

{

public:

        virtual void fun1()

        {

                cout<<"A::fun1"<<endl;

        }

        virtual void fun2()

        {

                cout<<"A::fun2"<<endl;

        }

        virtual void fun3()

        {

                cout<<"A::fun3"<<endl;

        }

};

class A1:public A

{

public:

        virtual void fun1()

        {

                cout<<"A1::fun1"<<endl;

        }

};

class A2:public A

{

public:

        virtual void fun2()

        {

                cout<<"A2::fun2"<<endl;

        }

        virtual void  fun3()

        {

                cout<<"A2::fun3"<<endl;

        }

};

class B :public A1,public A2

{

public:

        virtual void fun4()

        {

                cout<<"B::fun4"<<endl;

        }

};

typedef void (*Fun)(void);

int main(int argc, char* argv[])

{

        A1   a1;

        cout<<"A1虚函数表的地址为:"<<(int *)(&a1)<<endl;

        cout<<"A1第一个虚函数的地址为:"<<(int *) *(int *)(&a1)<<endl;

        Fun fun1,fun2,fun3,fun4;

        fun1=( Fun) ( *(int *) *(int *)(&a1));

        fun1();

        fun2=(Fun) (* ((int *) *(int *)(&a1)+1));

        fun2();

        fun3=(Fun) (* ((int *) *(int *)(&a1)+2));

        fun3();

        A2  a2;

        cout<<"A2虚函数表的地址为:"<<(int *)(&a2)<<endl;

        cout<<"A2第一个虚函数的地址为:"<<(int *) *(int *)(&a2)<<endl;

        fun1=( Fun) ( *(int *) *(int *)(&a2));

        fun1();

        fun2=(Fun) (* ((int *) *(int *)(&a2)+1));

        fun2();

        fun3=(Fun) (* ((int *) *(int *)(&a2)+2));

        fun3();

        B   b;

        cout<<"B的第一个虚函数表的地址为:"<<(int *)(&b)<<endl;

        cout<<"B的第一个虚函数表的第一个虚函数的地址为:"<<(int *) *(int *)(&b)<<endl;

        fun1=( Fun) ( *(int *) *(int *)(&b));

        fun1();

        fun2=(Fun) (* ((int *) *(int *)(&b)+1));

        fun2();

        fun3=(Fun) (* ((int *) *(int *)(&b)+2));

        fun3();

        fun4=(Fun) (* ((int *) *(int *)(&b)+3));

        fun4();

        cout<<"B的第二个虚函数表的地址为:"<<(int *)(&b)+1<<endl;

        cout<<"B的第二个虚函数表的第一个虚函数的地址为:"<<(int *) *((int *)(&b)+1)<<endl;

        fun1=( Fun) ( *(int *) *((int *)(&b)+1));

        fun1();

        fun2=(Fun) (* ((int *) *((int *)(&b)+1)+1));

        fun2();

        fun3=(Fun) (* ((int *) *((int *)(&b)+1)+2));

        fun3();

        return 0;

}

运行结果：

A1虚函数表的地址为:0xbfb2e9ec

A1第一个虚函数的地址为:0x8048ff0

A1::fun1

A::fun2

A::fun3

A2虚函数表的地址为:0xbfb2e9d8

A2第一个虚函数的地址为:0x8048fd8

A::fun1

A2::fun2

A2::fun3

B的第一个虚函数表的地址为:0xbfb2e9d0

B的第一个虚函数表的第一个虚函数的地址为:0x8048fa8

A1::fun1

A::fun2

A::fun3

B::fun4

B的第二个虚函数表的地址为:0xbfb2e9d4

B的第二个虚函数表的第一个虚函数的地址为:0x8048fc0

A::fun1

A2::fun2

A2::fun3

具体说下B的情况，b分别从A1,A2继承了两个虚函数表，这两个虚函数表也是在对象的开始按照顺序开始排列，先是A1的虚函数表，然后是A2的虚函数表。

B的第一个虚函数表：(int *)(&b)

B的第一个虚函数表的第一个元素fun1= * ((int *) * (int *)(&b))

B的第一个虚函数表的第二个元素fun2= * ((int *) * (int *)(&b)+1)

......

B的第二个虚函数表：(int *)(&b)+1

B的第二个虚函数表的第一个元素 fun1= * ((int *) *((int *)(&b)+1)+0)

B的第二个虚函数表的第二个元素 fun2= * ((int *) *((int *)(&b)+1)+1)

结果画成虚函数表如下：

A的虚函数表图：

A1的虚函数表图：

A2的虚函数表图：

B的虚函数表图：

结论：

多重继承会有多个虚函数表，几重继承，就会有几个虚函数表。这些表按照派生的顺序依次排列，如果子类改写了父类的虚函数，那么就会用子类自己的虚函数覆盖虚函数表的相应的位置，如果子类有新的虚函数，那么就添加到第一个虚函数表的末尾。

注意：这里由于类A1和A2都只有指向虚函数表的指针，所以对于类B而言，这两个指针连续。如果A1有个成员的为int类型，则B的第二个虚函数表：(int *)(&b)+2，例如：

#include<iostream>

using namespace std;

class Base1

{

  public:

    Base1(int num):num_1(num){}

    virtual void foo1() { cout << "Base1:: foo1" << num_1 << endl;}

    virtual void foo2() { cout << "Base1:: foo2" << num_1 << endl;}

    virtual void foo3() { cout << "Base1:: foo3" << num_1 << endl;}

  private:

    int num_1;

};

class Base2

{

  public:

    Base2(int num):num_2(num){}

    virtual void foo1() { cout << "Base2:: foo1" << num_2 << endl;}

    virtual void foo2() { cout << "Base2:: foo2" << num_2 << endl;}

    virtual void foo3() { cout << "Base2:: foo3" << num_2 << endl;}

  private:

    int num_2;

};

class Base3

{

  public:

    Base3(int num):num_3(num){}

    virtual void foo1() { cout << "Base3:: foo1" << num_3 << endl;}

    virtual void foo2() { cout << "Base3:: foo2" << num_3 << endl;}

    virtual void foo3() { cout << "Base3:: foo3" << num_3 << endl;}

  private:

    int num_3;

};

class Derived1:public Base1

{

  public:

    Derived1(int num):Base1(num){}

    virtual void faa1(){ cout << "Dervied1::faa1" <<endl;}

    virtual void faa2() { cout << "Dervied1::faa2" <<endl;}

};

class Derived2:public Base1

{

  public:

    Derived2(int num):Base1(num){}

    virtual void foo2(){ cout << "Dervied2::foo2" << endl;}

    virtual void fbb2(){ cout << "Dervied2::fbb2" << endl;}

    virtual void fbb3(){ cout << "Dervied2::fbb3" << endl;}

};

class Derived3:public Base1,public Base2,public Base3

{

  public:

    Derived3(int num_1,int num_2,int num_3):

         Base1(num_1),Base2(num_2),Base3(num_3){}

    virtual void fcc1(){ cout << "Dervied3::fcc1" << endl;}

    virtual void fcc2(){ cout << "Dervied3::fcc2" << endl;}

};

class Dervied4:public Base1,public Base2,public Base3

{

  public:

    Dervied4(int num_1,int num_2,int num_3):

         Base1(num_1),Base2(num_2),Base3(num_3){}

    virtual void foo1(){ cout << "Dervied4::foo1" << endl;}

    virtual void fdd(){ cout << "Dervied4::fdd" << endl;}

};

typedef void (*Fun)(void);

int main()

{

  Base1* pBase1 = NULL;

  Base2* pBase2 = NULL;

  Base3* pBase3 = NULL;

  Fun pFun;

cout << "--------------------------------" << endl;

  Derived1 d1(1);

  pBase1 = &d1;

  pBase1->foo1();

cout << "------------Derived1----------------" << endl;

  pFun = (Fun)*((int*)*(int*)(&d1)+0);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d1)+1);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d1)+2);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d1)+3);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d1)+4);

  pFun();

cout << "--------------------------------" << endl;

  Derived2 d2(2);

  pBase1 = &d2;

  pBase1->foo2();

cout << "------------Derived2----------------" << endl;

  pFun = (Fun)*((int*)*(int*)(&d2)+0);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d2)+1);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d2)+2);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d2)+3);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d2)+4);

  pFun();

cout << "--------------------------------" << endl;

  Derived3 d3(1,2,3);

  pBase1 = &d3;

  pBase2 = &d3;

  pBase3 = &d3;

  pBase1->foo1();

  pBase2->foo1();

  pBase3->foo1();

cout << "------------Derived3----------------" << endl;

  pFun = (Fun)*((int*)*(int*)(&d3)+0);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d3)+1);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d3)+2);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d3)+3);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d3)+4);

  pFun();

  pFun = (Fun)*((int*)*((int*)(&d3)+2)+0); // Base1 有一个int 类型的成员变量

  pFun();

  pFun = (Fun)*((int*)*((int*)(&d3)+2)+1);

  pFun();

  pFun = (Fun)*((int*)*((int*)(&d3)+2)+2);

  pFun();

  pFun = (Fun)*((int*)*((int*)(&d3)+4)+0); // Base2 有一个int 类型的成员变量

  pFun();

  pFun = (Fun)*((int*)*((int*)(&d3)+4)+1);

  pFun();

  pFun = (Fun)*((int*)*((int*)(&d3)+4)+2);

  pFun();

cout << "--------------------------------" << endl;

  Dervied4 d4(1,2,3);

  pBase1 = &d4;

  pBase2 = &d4;

  pBase3 = &d4;

  pBase1->foo1();

  pBase2->foo1();

  pBase3->foo1();

cout << "------------Derived4----------------" << endl;

  pFun = (Fun)*((int*)*(int*)(&d4)+0);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d4)+1);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d4)+2);

  pFun();

  pFun = (Fun)*((int*)*(int*)(&d4)+3);

  pFun();

  pFun = (Fun)*((int*)*((int*)(&d4)+2)+0); // Base1 有一个int 类型的成员变量

  pFun();

  pFun = (Fun)*((int*)*((int*)(&d4)+2)+1);

  pFun();

  pFun = (Fun)*((int*)*((int*)(&d4)+2)+2);

  pFun();

  pFun = (Fun)*((int*)*((int*)(&d4)+4)+0); // Base1 有一个int 类型的成员变量

  pFun();

  pFun = (Fun)*((int*)*((int*)(&d4)+4)+1);

  pFun();

  pFun = (Fun)*((int*)*((int*)(&d4)+4)+2);

  pFun();

  return 0;

}

运行结果：

--------------------------------

Base1:: foo11

------------Derived1----------------

Base1:: foo110843488

Base1:: foo210843488

Base1:: foo310843488

Dervied1::faa1

Dervied1::faa2

--------------------------------

Dervied2::foo2

------------Derived2----------------

Base1:: foo110843488

Dervied2::foo2

Base1:: foo310843488

Dervied2::fbb2

Dervied2::fbb3

--------------------------------

Base1:: foo11

Base2:: foo12

Base3:: foo13

------------Derived3----------------

Base1:: foo110843488

Base1:: foo210843488

Base1:: foo310843488

Dervied3::fcc1

Dervied3::fcc2

Base2:: foo110843488

Base2:: foo210843488

Base2:: foo310843488

Base3:: foo110843488

Base3:: foo210843488

Base3:: foo310843488

--------------------------------

Dervied4::foo1

Dervied4::foo1

Dervied4::foo1

------------Derived4----------------

Dervied4::foo1

Base1:: foo210843488

Base1:: foo310843488

Dervied4::fdd

Dervied4::foo1

Base2:: foo20

Base2:: foo30

Dervied4::foo1

Base3:: foo20

Base3:: foo30

C++ 虚函数表多重继承的更多相关文章

C++对象模型多重继承与虚函数表
一多重继承 1) 代码: Code#include <iostream>using namespace std; class B1{public: int x; virtua ...
详谈C++虚函数表那回事（多重继承关系）
上一篇说了一般继承,也就是单继承的虚函数表,接下来说说多重继承的虚函数表: 1.无虚函数覆盖的多重继承: 代码: #pragma once //无覆盖,多重继承 class Base1 { publi ...
[C++对象模型][8]多重继承与虚函数表
转载: [C++对象模型][8]多重继承与虚函数表一多重继承 1) 代码: Code #include <iostream> using namespace std; class B1 ...
C++ 虚函数表与多态 —— 多重继承的虚函数表 & 内存布局
多重继承的虚函数表会有两个虚表指针,分别指向两个虚函数表,如下代码中的 vptr_s_1.vptr_s_2,Son类继承自 Father 和 Mather 类,并且改写了 Father::func_1 ...
C++ 虚函数表解析
转载:陈皓 http://blog.csdn.net/haoel 前言 C++中的虚函数的作用主要是实现了多态的机制.关于多态,简而言之就是用父类型别的指针指向其子类的实例,然后通过父类的指针调用实 ...
C++虚函数表
大家知道虚函数是通过一张虚函数表来实现的.在这个表中,主要是一个类的虚函数的地址表,这张表解决了继承.覆盖的问题,其内容真是反应实际的函数.这样,在有虚函数的类的实例中,这个表分配在了这个实例的内存中 ...
C++虚函数与虚函数表
多态性可分为两类:静态多态和动态多态.函数重载和运算符重载实现的多态属于静态多态,动态多态性是通过虚函数实现的. 每个含有虚函数的类有一张虚函数表(vtbl),表中每一项是一个虚函数的地址, 也就是说 ...
C++的虚函数表
这里的例子全部来自陈皓的C++ 虚函数表解析,经过修改的. 编译器:g++ (Ubuntu 4.9.2-10ubuntu13) 4.9.2 环境:ubuntu 15.04 64位系统(地址占8字节) ...
C++虚函数表原理
C++中的虚函数的作用主要是实现了多态的机制.关于多态,简而言之就是用父类型别的指针指向其子类的实例,然后通过父类的指针调用实际子类的成员函数.这种技术可以让父类的指针有“多种形态”,这是一种泛型技 ...

随机推荐

[LeetCode] Binary Tree Longest Consecutive Sequence II 二叉树最长连续序列之二
Given a binary tree, you need to find the length of Longest Consecutive Path in Binary Tree. Especia ...
codeforces 868C Qualification Rounds
Snark and Philip are preparing the problemset for the upcoming pre-qualification round for semi-quar ...
[USACO13DEC]假期计划（黄金）Vacation Planning (gold)
题目翻译不好,这里给出一份题目背景 Awson是某国际学校信竞组的一只大佬.由于他太大佬了,于是干脆放弃了考前最后的集训,开车(他可是老司机)去度假.离开学校前,他打开地图,打算做些规划. 题目描述 ...
SAM维护的在线LCS
题目大意: 给定两个字符串,存在三种操作,分别是在a,b串末尾加一个字符串,和询问两串的LCS 题解: Get新套路:把两串建在同一SAM上,将重合的位置合并为同一节点,再加个标记数组,如果两者的LC ...
Python的序列类型——List
List 列表 List,本质是一个链表,从链表的实现角度来讲,链表的每一个结点都存放着值和指向下一个节点的指针. 因此链表在内存的存储可以是不连续的,它是一种高效的数据结构.因此列表与字符串的区别是 ...
ChatGirl is an AI ChatBot based on TensorFlow Seq2Seq Model
Introduction [Under developing,it is not working well yet.But you can just train,and run it.] ChatGi ...
Prometheus(转载)
Prometheus 系统监控方案一 https://www.cnblogs.com/vovlie/p/Prometheus_CONCEPTS.html 最近一直在折腾时序类型的数据库,经过一段时间 ...
如何用cmd通过sublime打开文件？
sublime 提供了专门的命令工具subl.exe,就在它的安装目录之下,讲安装目录配置到系统环境变量中就OK了.具体如下: 1.找到sublime安装路径如我的默认路径:C:\Program F ...
python读取文本文件数据
本文要点刚要: (一)读文本文件格式的数据函数:read_csv,read_table 1.读不同分隔符的文本文件,用参数sep 2.读无字段名(表头)的文本文件 ,用参数names 3.为文本文件制 ...
SpringMVC之简单的增删改查示例（SSM整合）
本篇文章主要介绍了SpringMVC之简单的增删改查示例(SSM整合),这个例子是基于SpringMVC+Spring+Mybatis实现的.有兴趣的可以了解一下. 虽然已经在做关于SpringMVC ...

C++ 虚函数表 多重继承

C++ 虚函数表 多重继承的更多相关文章

随机推荐

热门专题

C++ 虚函数表多重继承

C++ 虚函数表多重继承的更多相关文章