多态和多态的对象模型

最新推荐文章于 2024-01-23 17:56:39 发布

原创最新推荐文章于 2024-01-23 17:56:39 发布 · 362 阅读

0 ·

CC 4.0 BY-SA版权

C++ 专栏收录该内容

7 篇文章

订阅专栏

本文探讨了C++中的多态概念，包括静态多态和动态多态，并通过实例解释了虚函数与虚函数表的工作原理。文章还介绍了如何通过虚函数实现动态联编，以及虚函数表在内存中的组织方式。

C++多态和多态的对象模型

我们都知道，C++的三大特性– 封装，继承，多态。上一篇博客主要讲了多继承中的菱形继承（数据冗余和二义性），这篇博客主要谈谈多态和多态的对象模型。

首先，我觉得应该先理解一下什么是动态联编和静态联编？
（1）：静态联编：也称早期联编，非虚函数是静态联编，在编译阶段，由于类中的函数都是存在代码段的，所以它们的内存地址早已确定好。一句话总结，就是静态联编只与类型有关

（2）：动态联编：在编译阶段，编译器并不知道具体要调用哪个函数。只有等到运行时，才知道，为此，要知道调用的函数是哪个，要求联编工作在运行时进行。
动态联编 = 对象的指针或者引用 + 虚函数（不论有没有重写）

多态分为两种，静态多态和动态多态：

静态多态：编译时候的多态，指函数重载或运算符的重载。

动态多态：运行时候的多态，指基类（父类）指针或引用 + 虚函数重写。

可以通过下面这个例子，来更深刻理解一下：：

#include <iostream>
using namespace std;

class A
{
public:
    virtual void f1()
    {}
    void f2()
    {}
public:
    int _a;
};

int main()
{
    A* p = NULL;
    p->f1();//动态联编，程序会崩溃，因为会解引用
    p->f2();//程序不会崩溃，因为f2存在代码段，静态联编的时候
    //只在乎p的类型，
    p->_a = 0;//程序崩溃，因为要解引用
    return 0;
}

再来一个例子：

#include <iostream>
using namespace std;

class Father
{
public:
    void say()
    {
        cout << "Father" << endl;
    }
};

class Son : public Father
{
    void say()
    {
        cout << "Son" << endl;
    }
};
int main()
{
    Son s;
    Father* p = &s;//隐式类型转换

    p->say();//静态联编，编译器觉得 p 是Father*类型的，
    //所以它一定会指向Father类型的对象
    getchar();
    return 0;
}

对上面的代码稍稍改动一下，就变成了动态联编：

#include <iostream>
using namespace std;

class Father
{
public:
    virtual void say()//虚函数
    {
        cout << "Father" << endl;
    }
};

class Son : public Father
{
    virtual void say()//虚函数
    {
        cout << "Son" << endl;
    }
};
int main()
{
    Son s;
    Father* p = &s;//隐式类型转换

    p->say();//动态联编
    getchar();
    return 0;
}

下面我们就详细看一下这个过程：

虚函数表：简称虚表，就是存放类中虚函数内存地址的数组，实际上就是指针数组。
虚函数表指针：简称虚表指针，就是指向虚函数表的指针。

这里写图片描述
从汇编代码角度来看看：

结合虚拟继承来看看它的对象模型：

#include <iostream>
using namespace std;

class A
{
public:
    virtual void func()
    {
        cout << "A"<<endl;
    }
public:
    int _a;
};

class B :virtual public A
{
public:
    virtual void func1()
    {
        cout << "B" << endl;
    }
};

class C : virtual public A
{
public:
    virtual void func2()
    {
        cout << "C" << endl;
    }
};

class D : public B, public C
{
public:
    virtual void func3()
    {
        cout << "D" << endl;
    }
};
int main()
{
    A a;
    B b;
    C c;
    D d;
    cout << sizeof(a) << endl;//8
    cout << sizeof(b) << endl;//16
    cout << sizeof(c) << endl;//16 
    cout << sizeof(d) << endl;//24
    getchar();
    return 0;
}