多态、虚函数表、对象模型

最新推荐文章于 2024-01-28 14:34:41 发布
最新推荐文章于 2024-01-28 14:34:41 发布
阅读量432 收藏
点赞数
分类专栏： C++ 文章标签： 函数 多态 继承 虚函数 对象模型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/centor/article/details/76167872
版权
多态：

不同的对象收到相同的消息时，产生不同的动作。就是说有两个函数，同名，但是参数列表不同。能根据不同的参数传递实现不同的功能。也就是所谓“一个接口，多种方法”
静态多态：函数重载、模板
动态多态：虚函数

虚函数、虚表：

C++中虚函数的主要作用就是实现多态。简单说父类的指针/引用调用重写的虚函数，当父类指针/引用指向父类对象时调用的是父类的虚函数，指向子类对象时调用的是子类的虚函数；c++中用虚表来实现多态。虚函数表是通过一块连续内存来存储虚函数的地址。

虚函数要点：
  • 使用虚函数来实现多态时，派生类必须从它的基类公有派生
  • 首先必须在基类中定义虚函数
  • 在派生类中对基类中声明的虚函数进行重定义时，关键字virtual可以加也可以不加。为了不引起混乱，最好加上
  • 只有通过基类指针或引用访问虚函数时才能获得运行时的多态性
  • 一个虚函数无论被继承多少次，它仍然保持其虚函数的特性
  • 虚函数必须是其所在类的成员函数，而不能是友元函数，也不能是静态成员函数
  • 内联函数不能是虚函数，因为内联函数是不能在运行中动态确定其位置的
  • 构造函数不能是虚函数，但是析构函数可以是虚函数，而且通常说明为虚函数
函数重写、重载、重定义：
 作用域函数体
重载在同一作用域函数名相同，参数列表不同，与返回值类型无关
重写（覆盖）在不同作用域(基类和派生类）返回值、参数、函数名都相同（协变例外），基类函数必须有virtual修饰
重定义（隐藏）不同作用域（基类和派生类）在基类和派生类内不构成重写的同名函数就是重定义

协变：返回值类型可以不同，基类返回基类类型的指针或引用、派生类返回派生类类型的指针或引用
重载举例：

int Add(int a, int b);
double Add(double a, double b);

重写举例：

class Base
{
public:
    virtual void show()//基类必须是虚函数
    {
        cout<<"Base::show()"<<endl;
    }
};
class Derived:public Base
{
public:
    void show()
    {
        cout<<"Derived::show()"<<endl;
    }
};
int main()
{
    Derived d;
    d.show();//调用的是自己的show();而不是继承自基类的show()
    return 0;
}

运行结果
这里写图片描述

重定义（同名隐藏）举例：

class Base
{
public:
    void show()
    {
        cout<<"Base::show()"<<endl;
    }
};
class Derived:public Base
{
public:
    int show()
    {
        cout<<"Derived::show()"<<endl;
        return 1;
    }
};
int main()
{
    Derived d;
    d.show();//此处调用的是派生类内重定义的函数show()而不是继承自基类的show()
    return 0;
}

运行结果如下：
这里写图片描述

多态对象模型剖析：
1.单继承构成虚表的方式
  • 虚函数的顺序是类中声明顺序
  • 没有重写基类的虚函数之前，派生类的虚表和基类的虚表相同；重写之后，用派生类重写后的虚函数替换原来基类的虚表，定义新的虚函数按照自己声明次序排列在基类虚表的后面在基类虚表的后面
#include <iostream>
using namespace std;

class Base
{
public:
    virtual void Funtest1()
    {
        cout<<"Base::Funtest1()"<<endl;
    }
    virtual void Funtest2()
    {
        cout<<"Base::Funtest2()"<<endl;
    }
    virtual void Funtest3()
    {
        cout<<"Base::Funtest3()"<<endl;
    }
    int _b;
};
class Derived:public Base
{
public:
    virtual void Funtest2()
    {
        cout<<"Derived::Funtest2()"<<endl;
    }
    virtual void Funtest4()
    {
        cout<<"Derived::Funtest4()"<<endl;
    }
    virtual void Funtest5()
    {
        cout<<"Derived::Funtest5()"<<endl;
    }
    int _d;
};

typedef void (*pvFt)();

void print(Base& b)//打印虚表内容
{
    pvFt* p=(pvFt*)*(int*)&b;
    while (*p)
    {
        (*p)();
        p++;
    }
} 
void print(Derived& d)//此处打印是在清楚对象模型的基础上实现的
{
    pvFt* p=(pvFt*)*(int*)&d;
    while (*p)
    {
        (*p)();
        p++;
    }
} 
int main()
{
    Base b;
    Derived d;
    print(b);
    print(d);
    return 0;
}

运行结果：
这里写图片描述
那么虚表到底在哪，我们来研究一下基类和派生类的对象模型：
主函数添加如下代码，计算类对象模型大小

cout<<sizeof(b)<<endl;
cout<<sizeof(d)<<endl;//结果如下

这里写图片描述
在内存窗口可以看到对象模型，我们来分析一下：
这里写图片描述

2.多继承
#include <iostream>
using namespace std;

class C1
{
public:
    virtual void Funtest1()
    {
        cout<<"C1::Funtest1()"<<endl;
    }
    virtual void Funtest2()
    {
        cout<<"C1::Funtest2()"<<endl;
    }

    int _c1;
};

class C2
{
public:
    virtual void Funtest3()
    {
        cout<<"C2::Funtest3()"<<endl;
    }
    int _c2;
};

class D:public C1,public C2
{
public:
    virtual void Funtest4()
    {
        cout<<"D::Funtest4()"<<endl;
    }
    int _d;
};
typedef void (*pvFt)();
void print(C1& c1)//打印C1的虚表
{
    pvFt* p=(pvFt*)*(int*)(&c1);
    while (*p)
    {
        (*p)();
        p++;
    }
} 
void print(C2& c2)//打印C2的虚表
{
    pvFt* p=(pvFt*)*(int*)(&c2);
    while (*p)
    {
        (*p)();
        p++;
    }
} 
void print(D& d)//此处打印是在清楚对象模型的基础上实现的
{
    pvFt* p=(pvFt*)*(int*)&d;//打印继承自C1的虚表
    while (*p)
    {
        (*p)();
        p++;
    }
    pvFt* q=(pvFt*)*(((int*)&d)+2);//打印继承自C2的虚表
    while (*q)
    {
        (*q)();
        q++;
    }
} 
int main()
{
    C1 c1;
    c1._c1=1;
    C2 c2;
    c2._c2=2;
    D d;
    d._d=3;

    cout<<sizeof(d)<<endl;
    return 0;
}

如果派生类有自己新的虚函数，将跟在他的第一张虚表的后面，如上面程序中的Funtest4();对象模型大小也复合计算结果，是20字节

这里写图片描述

3.虚拟单继承
#include <iostream>
using namespace std;

class Base
{
public:
    virtual void Funtest1()
    {
        cout<<"Base::Funtest1()"<<endl;
    }
    virtual void Funtest2()
    {
        cout<<"Base::Funtest2()"<<endl;
    }
    int _b;
};
class D:virtual public Base
{
public:
    virtual void Funtest3()
    {
        cout<<"D::Funtest4()"<<endl;
    }
    int _d;
};
typedef void (*pvFt)();

void print(Base& b)
{
    pvFt* p=(pvFt*)*(int*)&b;
    while (*p)
    {
        (*p)();
        p++;
    }
} 
void print(D& d)//此处打印是在清楚对象模型的基础上实现的
{
    pvFt* p=(pvFt*)*(int*)&d;//打印D自己的虚表
    while (*p)
    {
        (*p)();
        p++;
    }
    pvFt* q=(pvFt*)*(((int*)&d)+3);//打印继承自Base的虚表
    while (*q)
    {
        (*q)();
        q++;
    }
} 
int main()
{
    D d;
    d._d=3;
    Base b;
    b._b=1;
    cout<<sizeof(d)<<endl;
    print(d);
    return 0;
}

下面分析d的对象模型，对象模型大小也复合计算结果，是20字节
点击查看关于偏移量表

这里写图片描述

4.菱形非虚拟继承

点击查看关于菱形继承相关概念
下面具体分析菱形非虚拟继承的派生类对象模型

#include <iostream>
using namespace std;

class Base
{
public:
    virtual void Funtest1()
    {
        cout<<"Base::Funtest1()"<<endl;
    }
    virtual void Funtest2()
    {
        cout<<"Base::Funtest2()"<<endl;
    }
    int _b;
};
class C1:public Base
{
public:
    virtual void Funtest2()
    {
        cout<<"C1::Funtest2()"<<endl;
    }
    virtual void Funtest3()
    {
        cout<<"C1::Funtest3()"<<endl;
    }

    int _c1;
};

class C2:public Base
{
public:
    virtual void Funtest4()
    {
        cout<<"C2::Funtest4()"<<endl;
    }
    int _c2;
};

class D:public C1,public C2
{
public:
    virtual void Funtest5()
    {
        cout<<"D::Funtest5()"<<endl;
    }
    int _d;
};
typedef void (*pvFt)();

void print(Base& b)
{
    pvFt* p=(pvFt*)*(int*)&b;
    while (*p)
    {
        (*p)();
        p++;
    }
} 
void print(C1& c1)
{
    pvFt* p=(pvFt*)*(int*)(&c1);
    while (*p)
    {
        (*p)();
        p++;
    }
} 
void print(C2& c2)
{
    pvFt* p=(pvFt*)*(int*)(&c2);
    while (*p)
    {
        (*p)();
        p++;
    }
} 
void print(D& d)//此处打印是在清楚对象模型的基础上实现的
{
    pvFt* p=(pvFt*)*(int*)&d;//打印继承自C1的虚表
    while (*p)
    {
        (*p)();
        p++;
    }
    pvFt* q=(pvFt*)*(((int*)&d)+3);//打印继承自C2的虚表
    while (*q)
    {
        (*q)();
        q++;
    }
} 
int main()
{
    C1 c1;
    c1._c1=11;//B
    C2 c2;
    c2._c2=12;//C
    Base b;
    b._b=1;
    D d;
    d._d=2;

    cout<<sizeof(d)<<endl;
    print(c1);
    cout<<endl;
    print(c2);
    cout<<endl;
    print(d);
    return 0;
}

菱形非虚拟继承其实是由两次单继承然后加一次多继承构成，符合单继承和多继承的继承特点，对象模型大小也复合计算结果，是28字节

这里写图片描述

5.菱形虚拟继承
#include <iostream>
using namespace std;

class Base
{
public:
    virtual void Funtest1()
    {
        cout<<"Base::Funtest1()"<<endl;
    }
    virtual void Funtest2()
    {
        cout<<"Base::Funtest2()"<<endl;
    }
    int _b;
};
class C1:virtual public Base
{
public:
    virtual void Funtest4()
    {
        cout<<"C1::Funtest4()"<<endl;
    }
    virtual void Funtest3()
    {
        cout<<"C1::Funtest3()"<<endl;
    }

    int _c1;
};

class C2:virtual public Base
{
public:
    virtual void Funtest5()
    {
        cout<<"C2::Funtest5()"<<endl;
    }
    int _c2;
};

class D:public C1,public C2
{
public:
    virtual void Funtest5()
    {
        cout<<"D::Funtest5()"<<endl;
    }
    int _d;
};
typedef void (*pvFt)();

void print(Base& b)
{
    pvFt* p=(pvFt*)*(int*)&b;
    while (*p)
    {
        (*p)();
        p++;
    }
} 
void print(C1& c1)
{
    pvFt* p=(pvFt*)*(int*)(&c1);
    while (*p)
    {
        (*p)();
        p++;
    }
} 
void print(C2& c2)
{
    pvFt* p=(pvFt*)*(int*)(&c2);
    while (*p)
    {
        (*p)();
        p++;
    }
} 
void print(D& d)//此处打印是在清楚对象模型的基础上实现的
{
    pvFt* p=(pvFt*)*(int*)&d;//打印继承自C1的虚表
    while (*p)
    {
        (*p)();
        p++;
    }
    pvFt* q=(pvFt*)*(((int*)&d)+3);//打印继承自C2的虚表
    while (*q)
    {
        (*q)();
        q++;
    }
    q=(pvFt*)*(((int*)&d)+7);//打印Base的虚表
    while (*q)
    {
        (*q)();
        q++;
    }
} 
int main()
{
    C1 c1;
    c1._c1=11;//B
    C2 c2;
    c2._c2=12;//C
    Base b;
    b._b=1;
    D d;
    d._d=2;

    cout<<sizeof(d)<<endl;
    print(c1);
    cout<<endl;
    print(c2);
    cout<<endl;
    print(d);
    return 0;
}

关于菱形虚拟继承在我的另一篇博客里有详细解述（点击查看）
菱形虚拟继承满足多态和继承的对象模型构建特性，事实也验证了对象模型的正确性。我们先看一下继承关系：

        这里写图片描述

这里写图片描述

centor
关注
专栏目录
多态和多态模型
青云衣兮白霓裳
11-25 577
1：什么多态？ 2：多态的对象模型–单继承&多继承？ 3：多态的对象模型–菱形继承和菱形虚拟继承？（选做）
图解C++多态，虚函数、虚函数表、虚指针、重写与覆盖
WYuan的博客
11-19 1960
多态         多态就是多种形态，C++的多态分为静态多态与动态多态。         静态多态就是编译器根据函数实参的类型判断出要调用哪个函数。比如函数重载和函数模板。         动态多态依靠的是虚函数表和动态绑定机制，因为是在运行时根据对象的类型在虚函数表中寻找调用函数的地址来调用相应的函数，所以称为动态多态。         本文仅
c++ 虚函数类对象模型
weixin_63612725的博客
08-22 128
形继承就有菱形虚拟继承，底层实现就很复杂。继承允许你根据基类的实现来定义派生类的实现。继承一定程度破坏了基类的封装，基类的改变，对派生类有很。对象组合是类继承之外的另一种复用选择。对象组合要求被组合的对象具有良好定义的接口。组合类之间没有很强的依赖关系，耦合度低。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有。些关系就适合继承那就用继承，另外要实现多态，也必须要继承。派生类和基类间的依赖关系很强，耦合度高。，因为对象的内部细节是不可见的。继承，可以用组合，就用组合。，就存在菱形继承，有了菱。
C++虚函数对象模型剖析
Fireplusplus的博客
06-16 531
测试环境：VS2013 C++中的类对象模型有简单的，也有复杂的。今天尝试着剖析一下，以加深对继承，虚函数等的理解。 从最简单的继承开始 class Base { public: int b; }; class Derive : public Base { public: int d; }; int main() { cout << sizeof(Derive) <<
实现多态——虚函数的对象模型
poison_biti的博客
07-21 426
多态的概念：（一个接口，多种方法）      多态是面向对象语言的三大特性（封装，继承，多态）之一，多态是指同一个实体具有多种形态。C++中的多态具体体现在编译和运行时期，编译时期就确定对象使用的形式（重载）我们成为编译时多态，运行时期才能确定 具体引用的对象使用的形式我们称为动态多态。同一操作作用于不同的对象，可以有不同的解释，产生不同的结果。多态在继承模型下实现，在运行时，可以通过指向基类（
【C++对象模型】之虚函数详解
李宁宁
11-13 516
Function语义学 Member function的各种调用方式1. Nonstatic Member Functions实际上member function被转换为nonmember function。C++设计准则就是：nonstatic member function至少必须和一般的nonmember function有相同的效率。
C++深度解析 C++对象模型分析（下） --- 继承对象模型，多态对象模型，虚函数表，用C语言实现多态（50）
Tim的嵌入式之旅
01-10 320
C++深度解析 C++对象模型分析（下） --- 继承对象模型，多态对象模型，虚函数表，用C语言实现多态（50）       继承对象模型 在C++编译器的内部类可以理解为结构体。 子类是由 父类成员 叠加 子类新成员 得到的。 代码如下：继承对象模型初探 #include &lt;iostream&gt; #include &lt;string&gt; using names...
C++虚函数表实例分析
01-21
多态是C++面向对象程序设计的一个重要特性。以前看到虚函数觉得很神奇，为...当我们通过父类指针来操作一个子类的时候，调用虚函数，都是通过虚函数表+固定的偏移，这样运行期多态便实现了。 在深度《深度》这本书中
C++多态（四）---虚函数表详解
董皓宇
12-26 296
C++多态 在C++多态（三）中已经得知，虚函数表地址存放在对象的内存模型中，通过该指针（vfptr），可以访问到该对象的虚函数表。 class Base { public: virtual void f(){ cout << "Base::f()" << endl; } virtual void g(){ cout << "Base::g()" <&...
多态&多态对象模型&虚函数表
baidu_37964044的博客
02-05 246
所谓多态，就是指多种形态 C++中虚函数的主要作用就是实现多态，简单说，父类的指针/引用调用重写的虚函数，当父类指针/引用指向父类对象时，调用的是父类的虚函数，指向子类对象调用的是子类的虚函数。 虚函数表 虚函数表（虚表）是通过一块连续内存来存储虚函数的地址，这张表解决了继承，虚函数（重写）的问题。在有虚函数的对象实例中都存在一张虚函数表，虚函数表就像一张地图，指名了实际应该调用的虚函数地址
类的动态多态与虚函数表：C++中的动态多态与虚函数表
最新发布
程序员光剑
01-28 521
1.背景介绍 在C++中，动态多态是一种在编译期间无法确定调用哪个函数的机制，它通常与虚函数有关。虚函数表(vtable)是实现动态多态的关键数据结构。本文将详细介绍C++中的动态多态与虚函数表的核心概念、算法原理、最佳实践、应用场景和未来发展趋势。 1. 背景介绍 在C++中，类的多态性是指同一种类型的对象可以被多种不同的方式使用。动态多态是指在运行时根据对象的实际类型来确定调用哪个函数。...
虚函数表--多态，动态绑定
zxf347085420的博客
02-16 346
虚函数，虚表，虚表指针，动态绑定，多态 ​
动态多态（虚函数、虚函数表、虚函数指针）
一抹阳光的博客
06-19 588
虚函数表就是存放虚函数地址的一个指针数组，虚函数指针就是指向虚函数表的一个指针。 同一个类的不同实例共用同一份虚函数表，他们都通过一个虚表指针指向该虚函数表。虚函数表是在编译期间创建好的，只存在一份。实例化类对象时，编译器自动将类对象的虚表指针指向虚函数表。 虚表指针是在调用构造函数时获得值的，所以构造函数一定不能是虚函数。（因为调用虚函数需要虚表指针获得地址，若构造函数是虚函数，此时虚表指针还没有赋值，无法调用）
继承关系作用下虚函数的手工调用
昔拉的博客
04-21 210
// project100.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include "pch.h" #include <iostream> using namespace std; //父类 class Base { public: virtual void f() { cout << "Base::f()" <<...
C++对象模型之虚函数
qq_40223389的博客
06-11 268
C++之虚函数 前言 本次笔记记录如下知识点 虚函数表指针位置分析 继承关系下虚函数的调用 虚函数表的分析 虚函数表指针位置分析 一个类中如果有虚函数，针对这个类会产生一个虚函数表，生成这个类对象的时候，该对象就有一个指针用来指向这个虚函数表的起始位置。 虚函数表指针位于对象内存的起始位置。 如下示例： #include <iostream> using namespace std; class A{ public: int i; virtual void fun(
C++对象模型和虚函数表分析以及重载、重写、隐藏的区别
FreeeLinux's blog
12-22 1264
C++在布局以及存取时间上主要的额外负担是由virtual引起的。包括：  Virtual function 机制 。用以支持一个有效率的“执行期绑定”（runtime binding）。  Virtual base class。用以实现“多次出现在继承体系中的base class，有一个单一而共享的实体”。  此外，还有一些多重继承下的额外负担。发生在“一个derived class
C++ 虚继承和虚函数同时存在的对象模型
chengonghao的博客
06-22 3012
如果说没有虚函数的虚继承只是一个噩梦的话，那么这里就是真正的炼狱。这个C++中最复杂的继承层次在VC上的实现其实我没有完全理解，摸爬滚打了一番也算得出了微软的实现方法吧，至于一些刁钻的实现方式我也想不到什么理由来解释它，也只算是知其然不知其所以然吧。   分2个阶段来探讨：   1.      有虚函数的派生类虚继承了没有虚函数的基类；   2.      有虚函数的派生类虚继承了有虚
C++中虚函数、虚指针和虚表详解
bob的博客
09-28 5325
关于虚函数的背景知识 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 存在虚函数的类都有一个一维的虚函数表叫做虚表。每一个类的对象都有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。 多态性是一个接口多种实现，是面向对象的核心。分为编译多态性和运行多态性。 运行多态用虚函数来实现，结合动态绑定。 纯虚函数是虚函数再加上=0。并且该函数只有声明，没有实现。 抽象类是指包括至少一个纯虚函数的类。 详细原理： 编译器在编译的时候，发现Base类中有虚函数，此时编译器
C++ 虚函数的对象模型
chengonghao的博客
06-18 2007
1.无继承的普通类：    在有虚函数的情况下类会为其增加一个隐藏的成员，虚函数表指针，指向一个虚函数表，虚函数表里面就是类的各个虚函数的地址了。那么，虚函数表指针是以什么模型加入到类里面的，虚函数表里面又是怎么安排的呢。简单来看下就可以知道了。 #include"stdafx.h" #pragma pack(8) class A{ public: int a
C++对象内存解析：数据分布与虚函数表揭秘
通过一个简单的示例展示了对象内存模型，并解释了虚函数表的工作原理以及重写和隐藏的概念。" 在C++中，对象的内存分布主要分为以下几个部分： 1. 非静态数据成员：每个对象实例都会拥有自己的非静态数据成员副本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值