从编译器的角度看C++的virtual函数

最新推荐文章于 2026-03-05 13:23:00 发布
转载 最新推荐文章于 2026-03-05 13:23:00 发布 · 508 阅读 · 0
标签
#编译器 #c++ #class #delete #c
#c#
本文深入探讨C++中的多态实现原理，包括VTABLE机制、多层次类中的virtual使用、virtual析构函数的重要性、private虚函数及构造函数和析构函数中调用virtual函数的行为。

http://www.cnblogs.com/fte99923/archive/2011/04/24/2026517.html

晚自习和秦多铎讨论了C++里多态的问题，发现自己在这方面存在两个严重问题：

1.以前只是知其然，但不知所以然，只知道怎么实现多态，但不明白编译器内部大概是怎么实现的，也就导致了编程时很多细节处需要翻书。

2.C#后遗症很严重，用VC6写小程序验证自己想法的时候好几次编译不通过。

多铎在网上找了一篇技术贴（http://user.qzone.qq.com/624576542/blog/1303304079）

帖子内容非常赞，但是重点不够突出（什么是多态、怎么用多态这样的基础问题这帖子也不厌其烦地讲），也有说得不太明白、模棱两可的地方。

按照里边的知识点，编了几个小程序测试了下，梳理了一下思路，总结如下：

（零）VTABLE机制

当一个类中有virtual函数时，编译器会为这个类建立且仅建立一个VTABLE

这个VTABLE大概是个数组的感觉，其元素是“函数指针”。

所以说，下边这段代码：

    

      1 
     class
      A

      2 
     {

      3 
      
     public
     :

      4 
            
     virtual
      
     void
      f0() {cout
     <<
     "
     a0
     "
     <<
     endl}；

      5 
     

      6 
            
     virtual
      
     void
      f1() {cout
     <<
     "
     a1
     "
     <<
     endl}；

      7 
     

      8 
            
     virtual
      
     void
      f2() {cout
     <<
     "
     a2
     "
     <<
     endl}；

      9 
     

     10 
     };

     11 
     

     12 
      
     class
      B: 
     public
      A

     13 
     {

     14 
      
     public
     :

     15 
            
     virtual
      
     void
      f0() {cout
     <<
     "
     b0
     "
     <<
     endl}；

     16 
     

     17 
            
     virtual
      
     void
      f1() {cout
     <<
     "
     b1
     "
     <<
     endl}；

     18 
     

     19 
            
     virtual
      
     void
      f2() {cout
     <<
     "
     b2
     "
     <<
     endl}；

     20 
     

     21 
     };

编译器会给类A和类B各自建一个VTABLE：

VTABLE_A的0,1,2个元素分别放的是指向A::f0() , A::f1() , A::f2()的指针

VTABLE_B的0,1,2个元素分别放的是指向B::f0() , B::f1() , B::f2()的指针

而对每个实际的类对象，编译器会增加一个vptr字段

（注：这也是很多笔经面经里说的sizeof(A)和sizeof(B)里多出4的问题的原因，多出来这4个Byte就是给vptr指针分配的空间，由此引发的sizeof对齐问题经常被问到）

而下边这段代码：

    

     A 
     *
     a 
     =
      
     new
      B;

a
     ->
     f1();　　　　
     //
     这里，编译器实际上做的是a->vptr[1]();这样，实际上运行的是VTABLE_B[1]指向的函数

这样看来，以前很多死记硬背的细节，哪里是override，哪里是overload，调用的到底是哪个函数，用vptr和VTABLE的概念就很好理解了

（一）多层次类中的virtrual

看下边的代码：

    

     class
      A
{

     public
     :
    
     virtual
      
     void
      f(){cout
     <<
     "
     a
     "
     <<
     endl;}
    
     void
      g(){cout
     <<
     "
     ag
     "
     <<
     endl;}
};


     class
      B: 
     public
      A
{

     public
     :
    
     void
      f(){cout
     <<
     "
     b
     "
     <<
     endl;}    　　
     //
      B::f()没有virtual关键字!
     

     };


     class
      C: 
     public
      B 　　　　
     //
      C继承的是B，而B中没有显式的virtual
     

     
{

     public
     :
    
     void
      f(){cout
     <<
     "
     c
     "
     <<
     endl;}    　　　　
     //
      C中的f也没有virtual关键字！
     

         
     void
      g(){cout
     <<
     "
     cg
     "
     <<
     endl;}
};


     void
      main()
{
 A 
     *
     a 
     =
      
     new
      C();
 a
     ->
     f();  
     //
      这里调用了C::f()，实际上是a->vptr[0]();
     

      a
     ->
     g();  
     //
      这里调用的是A::g(),因为g在A中不是virtual的
     

     
 delete a;
 a 
     =
      
     new
      B();
 a
     ->
     f();  
     //
      （这行语句加得有点蛋疼，只是为了测试得更完整）这里调用了B::f()，a->vptr[0]();
     

      delete a;
}

A::f()是virtual的，但B::f()和C::f()都没有显式声明virtual

而实际上，C::f()是多态了A::f()的。

说穿了很简单，编译器给A建立了VTABLE，也就会给A的每个派生类都建立VTABLE（哪怕是孙子辈的C）

而A,B,C类中VTABLE中元素的顺序都是一样的（这个例子只有1个f()，如果A还有virtual的f2,f3，那么B和C的VTABLE中的相应位置中也会存放B,C版本的f2,f3）

（二）virtual析构函数

基本上，C++的多态，都要“虚”一下析构函数（这1年来C#用得多，人都变傻了，前几天电面的时候，面试官和我聊多态，“虚析构”这地方还被鄙视了下=。=）

    

      1 
     class
      A

      2 
     {

      3 
     
     public
     :

      4 
         A() { cout
     <<
     "
     A()
     "
     <<
     endl;ptra_ 
     =
      
     new
      
     char
     [
     10
     ];}

      5 
         
     virtual
      
     ~
     A() { cout
     <<
     "
     ~A()
     "
     <<
     endl; delete[] ptra_;}        
     //
      注意：这里如果不“虚”一下，main函数里调用的顺序是A(),B(),~A()

      6 
     

      7 
     　　　　　　　　　　　　　　　　　　　　　　　　    
     //
      “虚”了之后，main里调用顺序是A(),B(),~B(),~A()
     

      8 
     
     

      9 
     
     private
     :

     10 
         
     char
      
     *
      ptra_;

     11 
     };

     12 
     

     13 
     
     class
      B: 
     public
      A

     14 
     {

     15 
     
     public
     :

     16 
         B() { cout
     <<
     "
     B()
     "
     <<
     endl;ptrb_ 
     =
      
     new
      
     char
     [
     20
     ];}

     17 
         
     ~
     B() { cout
     <<
     "
     ~B()
     "
     <<
     endl; delete[] ptrb_;}

     18 
     
     private
     :

     19 
         
     char
      
     *
      ptrb_;

     20 
     };

     21 
     

     22 
     
     void
      main()

     23 
     {

     24 
      A 
     *
      a 
     =
      
     new
      B;

     25 
         delete a;

     26 
     }

由此可见，C++里用多态，除非你的程序很土，从来没new过堆空间，否则“虚析构”是必用的。

另：构造函数不能虚！

（三）private虚函数

  

    

     class
      A
{

     public
     :
    
     void
      foo() { bar();} 
     //
      实际上这里是调用了this->vptr[0]，具体调用了谁，要看“this”指向的谁
     

     private
     :
    
     virtual
      
     void
      bar() {cout
     <<
     "
     a
     "
     <<
     endl;}
};


     class
      B: 
     public
      A
{

     private
     :
    
     virtual
      
     void
      bar() { cout
     <<
     "
     b
     "
     <<
     endl;}
};


     void
      main()
{
 A 
     *
     a 
     =
      
     new
      B();
 a
     ->
     foo(); 　　　　
     //
     a指向的是B，所以a->vptr[0]调用的是VTABLE_B[0]指向的函数，即B::bar()
     

     }

（四）构造函数和析构函数中调用virtual函数

  

    

     class
      A
{

     public
     :
    A() { cout
     <<
     "
     A()
     "
     <<
     endl;foo();}        
     //
      在这里，无论如何都是A::foo()被调用！
     

         
     ~
     A() { cout
     <<
     "
     ~A()
     "
     <<
     endl;foo();}       
     //
      同上
     

         
     virtual
      
     void
      foo(){cout
     <<
     "
     a
     "
     <<
     endl;}
};


     class
      B: 
     public
      A
{

     public
     :
    
     virtual
      
     void
      foo(){cout
     <<
     "
     b
     "
     <<
     endl;}
};


     class
      C: 
     public
      B
{

     public
     :
 
     virtual
      
     void
      foo(){cout
     <<
     "
     c
     "
     <<
     endl;}
};


     void
      main()
{
 A 
     *
     a 
     =
      
     new
      B;
    delete a;
 B 
     *
     b 
     =
      
     new
      C;
 delete b;
 cout
     <<
     sizeof
     (A)
     <<
     endl;
 cout
     <<
     sizeof
     (B)
     <<
     endl;
 
     //
      2个构造、2个析构都调用的a::foo()
 
     //
      无责任猜想，应该是构造函数被调用时，B的vptr还没做成；而析构函数被调用时，vptr已被撤销，所以不能通过B::vptr饮用B的VTABLE
     

     }

（五）C#后遗症两条

1.多态的实现是用指针，而不是对象

 

    

     Base 
     base
      
     =
      
     new
      Derived;　　　　
     //
     这是多态不了的，因为实际上是进行了Derived到Base的强制类型转换，转完之后实际上还是Base类的VTABLE
     

     
Base 
     *
     base
      
     =
     new
      Derived;　　　　
     //
     这里base指针指向了Derived对象，base->f()调用的是“被指向的Derived对象”的vptr字段，即Derived类的VTABLE中的元素

2.C#的base关键字和Java的super关键字，C++里木有

想实现类似的功能，直接用父类的类名和“::”运算符，即：

    

     Class B : 
     public
      A

{

　　　　
     virtual
      
     void
      f() { A::f(); cout
     <<
     "
     f() in B
     "
     <<
     endl;

}

这样。



编译器角度看C++复制构造函数
12-22
关于复制构造函数的简单介绍，可以看我以前写过的一篇文章Ｃ＋＋复制控制之复制构造函数该文章中介绍了复制构造函数的定义、调用时机、也对编译器合成的复制构造函数行为做了简单说明。本文因需要会涉及到上文的一些知识点，但还是推荐先阅读上文。 　　本文主要从编译器角度对复制构造函数进行分析，纠正以前对复制构造函数的一些错误认识。 　　浅拷贝（deep copy）与深拷贝(shallow copy) 　　我们首先来看复制构造函数涉及的两个概念：浅拷贝与深拷贝。假设有两个对象：A与B，它们是同类型的，下面分析B=A时浅拷贝与深拷贝行为。 　　浅拷贝： 　　浅拷贝简单地把B复制为A的引用或指针，可以认
C++ 多继承和虚继承的内存布局(Memory Layout for Multiple and Virtual Inheritance)
luguifang2011的专栏
12-31 1773
C++ 多继承和虚继承的内存布局(Memory Layout for Multiple and Virtual Inheritance)
编译器对c++的头文件有看法哦，反正编译器是大佬
oooooooooooooookjk的博客
02-01 348
项目属性----〉配置属性----&gt;c/c+±—&gt;常规—&gt;附加包含目录-----&gt;$(ProjectDir) 缺少vs2017缺少头文件的解决方法 1.调出项目属性页，选择vc++目录 2.包含目录添加头文件路径 3.库目录中添加路径 每次添加都太麻烦了，新建项目都要重新添加，进行通用设置。 选中属性管理器，再点击“Debug|Win32&gt;&gt;MicroSoft....
从编译器角度来理解C++代码的编译和链接原理
surplus12138的博客
10-04 343
我们可以在linux系统下进行对下列代码是如何进行编译进行一个理解 main.cpp： //引用sum.cpp文件里面定义的全局变量以及函数 extern int gdata; int sum (int, int) ; int data = 20; int main () { int a = gdata; int b = data; int ret =sum (a, b); return o; } sum.cpp： int gdata = 10; int sum(int a, int b) {
从编译器角度看本质：C/C++ 中 volatile 关键字详解
君之剑的专栏
08-12 450
目的：建立语言级别的 memory barrier 实现：声明的类型变量表示可以被某些编译器未知的因素更改，编译器对访问该变量的代码就不再进行优化，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据，而且读取的数据立刻被保存。 实践： 1) 中断服务程序中修改的供其它程序检测的变量需要加 volatile； 2) 多任务（多线程）环境下各任务间共享的标志应该加 vol...
C++的virtual函数（从编译器的角度看）
mumushou
07-13 998
编了几个小程序测试了下，梳理了一下思路，总结如下：（零）VTABLE机制当一个类中有virtual函数时，编译器会为这个类建立且仅建立一个VTABLE这个VTABLE大概是个数组的感觉，其元素是“函数指针”。所以说，下边这段代码： 1 class A 2 { 3  publi
C++构造与析构(17) - virtual拷贝构造函数
05-25 1128
C++构造与析构(17) - virtual拷贝构造函数
c++面向对象编程:多态性，虚函数，抽象类，纯虚函数
weixin_43821215的博客
03-22 6599
系列文章目录 第一章 c++继承 第二章c++指针 第三章c++运算符重载 文章目录系列文章目录前言一、类继承层次中对象之间的关系1.从派生类对象调用基类函数2.将派生类指针指向基类对象3.通过基类指针调用派生类的成员函数二、virtual函数和virtual析构函数1.virtual函数2.virtual函数的声明3.调用虚函数4.虚析构函数5.final成员函数和类三、抽象类和纯虚函数1.抽象类2.纯虚函数总结 前言 最近在准备研究生复试，学习c++，就当作是学习笔记了 一、类继承层次中对象之间的
C++ Virtual详解
dayuqi的专栏
09-07 702
纯虚函数： 　　C++语言为我们提供了一种语法结构，通过它可以指明，一个虚拟函数只是提供了一个可被子类型改写的接口。但是，它本身并不能通过虚拟机制被调用。这就是纯虚拟函数（pure virtual function）。 纯虚拟函数的声明如下所示：          　　这里函数声明后面紧跟赋值0。 　　包含（或继承）一个或多个纯虚拟函数的类被编译器识别为抽象基类。试图创建一个抽象基类的独立
条款09：绝不在构造和析构过程中调用virtual函数
最新发布
大胡子的博客
03-05 1403
摘要：在C++中，构造和析构期间调用虚函数存在风险。由于基类构造时派生类成员未初始化，虚函数会被解析为基类版本而非预期的派生类版本（如示例中Transaction基类调用自身logTransaction而非BuyTransaction的实现）。同理，析构时派生类成员已销毁，虚函数也会退化为基类行为。解决方案是通过派生类构造函数将信息向上传递给基类非虚函数处理（如传递日志字符串）。核心原则：构造/析构期间避免虚函数调用，此时对象类型被视为当前构造层级的类，多态机制失效。该规则同样影响RTTI（如dynamic
C++57个入门知识点_32 初识多态及虚函数-核心（加virtual的函数称为虚函数；某一个函数在父子类有不同实现，运行时对象自行决定调用哪一类实现；没virtual调父类同名函数，否则调子类函数）
分享学习成长历程，Winter is coming！
10-30 506
1.什么是多态： 某一个函数在父类子类有不同的实现，运行时对象自行决定调用哪一个类下实现 （1）常规下我们要实现，一个房间多国人，不同国家的人说不同的话 #include <iostream> //面向对象：多态 class CPerson { public: CPerson() { } void speak() { printf("说人话\r\n"); } }; class CChinese :public CPerson { public: CChinese()
C++之《Effective C++》读书总结(3)
梅花香自苦寒来，宝剑锋从磨砺出。
02-03 1315
本文摘要总结了《Effective C++》第三部分关于实现优化的关键建议： 推迟变量定义：在首次使用时定义变量，避免不必要的构造/析构开销，同时提高代码可读性。建议定义时直接初始化而非先定义后赋值。 减少类型转换：避免使用C风格强制转换，优先使用语义明确的新式转换（static_cast等）。特别警惕dynamic_cast的性能开销和多态设计问题。 避免返回内部句柄：不要返回指向对象内部成员的指针/引用，以维护封装性，防止const语义破坏和悬空引用问题。 异常安全保证：确保代码在异常发生时至少满足基本
c++多态性 虚函数
qq_38251888的博客
12-11 296
c++中多态性是指通过用virtual关键字来绑定同名同参数的函数，实现在编译中进行后绑定，即在编译过程中不绑定类，在运行时与具体的对象进行绑定，这样就可以动态地与实际联系 比如一个类 animal 有一个虚函数breath() 鱼类 fish 也有函数breath() 狗类 dog 函数breath() 具体调用时根据你的对象是鱼类还是狗类有关 C++的多态性用一句话概括就是：在基类的函数...
C++的多态性
swj9099的博客
05-15 333
C++的多态性用一句话概括就是：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数 1：用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2：存在虚函数的类都有一个一维的虚函数表叫做虚表，类的对象有一个指向虚表开始的虚指针。虚...
【C++ 20 】C++20中constexpr的增强
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
08-10 2075
C++20 对 `constexpr` 的扩展是其一大亮点，使得更多的代码可以在编译期进行计算，进而减少运行时的开销。以下是一些具体的扩展和改进：
【C++】继承以及菱形虚拟继承（virtual修饰）解析
Zhou000815的博客
05-02 578
目录前言：面向对象（OO）三大特性继承 前言：面向对象（OO）三大特性 继承
C++之我见--多态(虚函数和纯虚函数)
我爱我家
06-21 936
目录 多态性 虚函数原理 有关基类是否必须要实现虚函数、子类是否必须实现基类纯虚函数 重载与多态无关 进入正题之前先温故几个点： 多态，字面意思理解就是多种形态，对于C++而言则是调用成员函数时，会根据调用函数的对象的类型来执行不同的函数； C++多态的前提是，类之间存在层次结构，并且类之间是通过继承关联的； 虚函数，基类中使用virtual关键字声明的函数； 纯虚函数，...
Effective C++ 条款30 透彻了解inlining的里里外外
qq_18059143的博客
12-07 290
1.inline 的优缺点 > 优点 ——看起来像函数 ——动作像函数 ——比宏好很多 ——可以调用它们又不需要蒙受函数调用所招致的额外开销 ——编译器最优化机制通常被设计用来浓缩那些“不含函数调用”的代码，所以当你inline某个函数，或许编译器就因此——有能力对它（函数本体）执行预警相关最优化。大部分的编译器不会对一个“outlined函数调用”动作执行如此之最优化 > 缺点 ——可能增加目标码（object code）的大小 ——inline造成的代码膨胀会导致额外的换页行为，降低指令告诉
C++ 多态的实现及原理
BlueBirdssh的专栏
03-06 146
C++的多态性用一句话概括就是：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数 1：用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2：存在虚函数的类都有一个一维的虚函数表叫做虚表，类的对象有一个指向虚表开始的虚指针。虚...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值