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

最新推荐文章于 2024-07-10 22:49:54 发布
最新推荐文章于 2024-07-10 22:49:54 发布
阅读量428 收藏
点赞数
分类专栏： C/C++ 文章标签： 编译器 c++ class delete c c#

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;

}

这样。



changan2001
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++中的virtual析构函数
FAS ------ 一颗好奇心，一页好代码！
06-30 403
为什么C++的一个类需要被继承时，需要把这个类的析构函数声明为虚函数（virtual修饰）
C++ 虚析构函数(析构函数加virtual)
MengShang_Cpp的博客
06-28 344
C++析构函数前面加virtual的原因
编译器角度看C++复制构造函数
12-22
关于复制构造函数的简单介绍，可以看我以前写过的一篇文章Ｃ＋＋复制控制之复制构造函数该文章中介绍了复制构造函数的定义、调用时机、也对编译器合成的复制构造函数行为做了简单说明。本文因需要会涉及到上文的一些知识点，但还是推荐先阅读上文。 　　本文主要从编译器角度对复制构造函数进行分析，纠正以前对复制构造函数的一些错误认识。 　　浅拷贝（deep copy）与深拷贝(shallow copy) 　　我们首先来看复制构造函数涉及的两个概念：浅拷贝与深拷贝。假设有两个对象：A与B，它们是同类型的，下面分析B=A时浅拷贝与深拷贝行为。 　　浅拷贝： 　　浅拷贝简单地把B复制为A的引用或指针，可以认
编译器对c++的头文件有看法哦，反正编译器是大佬
oooooooooooooookjk的博客
02-01 259
项目属性----〉配置属性----&gt;c/c+±—&gt;常规—&gt;附加包含目录-----&gt;$(ProjectDir) 缺少vs2017缺少头文件的解决方法 1.调出项目属性页，选择vc++目录 2.包含目录添加头文件路径 3.库目录中添加路径 每次添加都太麻烦了，新建项目都要重新添加，进行通用设置。 选中属性管理器，再点击“Debug|Win32&gt;&gt;MicroSoft....
从编译器角度看本质：C/C++ 中 volatile 关键字详解
君之剑的专栏
08-12 276
目的：建立语言级别的 memory barrier 实现：声明的类型变量表示可以被某些编译器未知的因素更改，编译器对访问该变量的代码就不再进行优化，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据，而且读取的数据立刻被保存。 实践： 1) 中断服务程序中修改的供其它程序检测的变量需要加 volatile； 2) 多任务（多线程）环境下各任务间共享的标志应该加 vol...
从编译器角度来理解C++代码的编译和链接原理
surplus12138的博客
10-04 200
我们可以在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++ 虚函数专题
12-17
在C++中，虚函数的声明通常是在基类中使用`virtual`关键字来完成的。例如： ```cpp class Base { public: virtual void f() { cout ; } virtual void g() { cout ; } virtual void h() { cout ; } }; ``` 在这...
从汇编看c++中默认构造函数的使用分析
09-05
然而，从汇编层面来看，这个过程并非总是涉及实际的函数调用。下面我们将深入探讨这一点。 首先，我们看一个简单的例子，类`X`只有一个`int`类型的成员变量`i`： ```cpp class X { private: int i; }; int main...
深入解析C++中的虚函数与多态
01-21
对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）和一个指向虚函数表的指针（vptr）来实现的。虚函数表，简称为vtbl，虚函数表表对实现多态起着至关重要
浅谈C++中virtual的三种用法
08-18
本文将详细介绍C++中virtual的三种用法，分别是虚函数、虚继承和虚析构。 一、虚函数 虚函数是一种特殊的成员函数，它可以被派生类重写。虚函数的主要特点是可以在编译时不知道实际调用的对象类型，而是在运行时...
C++中的虚函数(virtual function).rar_C++虚函数_虚函数
09-14
在C++编程语言中，虚函数（virtual function）是一个核心特性，它允许程序员实现多态性，这是面向对象编程中的重要概念。多态性意味着一个基类指针或引用可以调用不同派生类中重定义的同名成员函数。通过使用虚函数...
C++ 多态
最新发布
wxk2227814847的博客
07-10 747
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
初始C++
2302_81016149的博客
07-08 790
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
C++初探究（2）
Frenemy__的博客
07-09 1450
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 1001
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
C++：CV::Point函数简介
Ethan_Rich的博客
07-08 436
cv::Point是 OpenCV 库中用于表示二维坐标系下点的一个基本数据类型。它提供了在图像处理、计算机视觉等领域中定位和操作点的能力。以下是关于cv::Point。
Python的异常处理（与C++对比学习）
2302_76941579的博客
07-09 947
通过C++的基础来学习Python的异常处理
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言
星羽空间
07-09 340
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值