C++ 多态（三）多继承关系的虚函数表与常见问题

最新推荐文章于 2024-04-25 12:18:13 发布

东区东区！

最新推荐文章于 2024-04-25 12:18:13 发布

阅读量1k

点赞数

分类专栏： C++ 文章标签： c++ 开发语言 Powered by 金山文档

本文链接：https://blog.csdn.net/weixin_59215611/article/details/129612607

版权

C++ 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

5.单继承和多继承关系的虚函数表

5.1 多继承中的虚函数表

两个基类及他们的虚表如下

创建子类如下

class D : public B1, public B2
{
public:
    virtual void func1()
    {
        cout << "D::func1()" << endl;
    }

    virtual void func4()
    {
        cout << "D::func4()" << endl;
    }

    virtual void func5()
    {
        cout << "D::func5()" << endl;
    }

    int _d;
};

D有两个基类，第一部分从B1继承，第二部分从B2继承，第三部分为派生类新增加的部分

子类对象模型如下：每一行4字节，共20字节，不同颜色框对应其分别的地址

子类虚表中按顺序进行分析：

首先继承B1，此时虚表中如下

应为子类中Func1进行了重写，B1::func1（）覆盖为D::func1。func1,2,3,4都在基类中有过，子类中还新增了func5，更新的虚表如下

B2继承，子类重写了func4，新增func5只放在B1中，B2不会增加，更新虚表，此时B1,B2虚表是分开的，互不影响

我们打印2个虚表查看,证明

typedef void (*PVFT)();

void PrintB1VFT(B1& b, const string& info)
{
    cout << info << endl;
    PVFT* pvft = (PVFT*)*(int*)&b;//找到虚表地址
    while (*pvft) //循环拿到虚表中的虚函数
    {
        (*pvft)();
        pvft++;
    }
    cout << "==================" << endl;
}

void PrintB2VFT(B2& b, const string& info)
{
    cout << info << endl;
    PVFT* pvft = (PVFT*)*(int*)&b; 
    while (*pvft)
    {
        (*pvft)();
        pvft++;
    }
    cout << "==================" << endl;
}

int main()
{
    cout << sizeof(D) << endl;

    D d;
    d._b1 = 1;
    d._b2 = 2;
    d._d = 3;

    PrintB1VFT(d, "B1 of D VFT:");
    PrintB2VFT(d, "B2 of D VFT:");

    return 0;
}

注意：在多继承中，子类新增加的虚函数地址放到第一张虚表后

6. 继承和多态常见的面试问题

6.1 概念查考

1. 下面哪种面向对象的方法可以让你变得富有( )

A: 继承 B: 封装 C: 多态 D: 抽象

2. ( )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，而对方法的调用则可以关联于具体的对象。

A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定

3. 面向对象设计中的继承和组合，下面说法错误的是？（）

A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复用，也称为白盒复用

B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动态复用，也称为黑盒复用

C：优先使用继承，而不是组合，是面向对象设计的第二原则

D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封装性的表现

4. 以下关于纯虚函数的说法,正确的是( )

A：声明纯虚函数的类不能实例化对象 B：声明纯虚函数的类是虚基类

C：子类必须实现基类的纯虚函数 D：纯虚函数必须是空函数

5. 关于虚函数的描述正确的是( )

A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型

B：内联函数不能是虚函数

C：派生类必须重新定义基类的虚函数 D：虚函数可以是一个static型的函数

6. 关于虚表说法正确的是（）

A：一个类只能有一张虚表

B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表

C：虚表是在运行期间动态生成的

D：一个类的不同对象共享该类的虚表

7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（）

A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址

B：A类对象和B类对象前4个字节存储的都是虚基表的地址

C：A类对象和B类对象前4个字节存储的虚表地址相同

D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表

8. 下面程序输出结果是什么? （）

class A{
public:
 A(char *s) { cout<<s<<endl; }
 ~A(){}
};
class B:virtual public A
{
public:
     B(char *s1,char*s2):A(s1)
     { cout<<s2<<endl; }
};
class C:virtual public A
{
public:
     C(char *s1,char*s2):A(s1)
     { cout<<s2<<endl; }
};
class D:public B,public C
{
public:
     D(char *s1,char *s2,char *s3,char *s4):B(s1,s2),C(s1,s3),A(s1)
     { cout<<s4<<endl;}
};
int main()
 {
     D *p=new D("class A","class B","class C","class D");
     delete p;
     return 0;
}

A：class A class B class C class D B：class D class B class C class A

C：class D class C class B class A D：class A class C class B class D

理论分析：

分析结果如下

上述调用分析没错，但是，classA只存储一份，基类A的构造方法只执行一次，在之后BCD执行时，A便不在执行（上图中，在D位置内，进入发现需要构造BCA，但是A是基类只有一份，所以首先直接执行A，之后在BC中遇到A就不需要再次构造执行）

9. 多继承中指针偏移问题？下面说法正确的是( )

class Base1 {  public:  int _b1; };
class Base2 {  public:  int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main(){
 Derive d;
 Base1* p1 = &d;
 Base2* p2 = &d;
 Derive* p3 = &d;
 return 0;
}

A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3

10. 以下程序输出结果是什么（）

 class A
   {
   public:
       virtual void func(int val = 1) 
       {     std::cout<<"A->"<< val <<std::endl;    }
       virtual void test()
        { func();}
   };
   
   class B : public A
   {
   public:
       void func(int val=0)
        { std::cout<<"B->"<< val <<std::endl; }
   };
   
   int main(int argc ,char* argv[])
   {
       B*p = new B;
       p->test();
       return 0;
   }

A: A->0 B: B->1

C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

P->test，子类没有，只能找基类A，A中有func函数

参考答案：

1. A 2. D 3. C 4. A 5. B

6. D 7. D 8. A 9. C 10. B