虚函数总结

最新推荐文章于 2020-10-17 14:52:57 发布
最新推荐文章于 2020-10-17 14:52:57 发布
阅读量422 收藏
点赞数
分类专栏： C++ 文章标签： C++ 虚函数 面向对象 oop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cheng_1992/article/details/74090635
版权

多态（Polymorphism），是面向对象程序设计（OOP，Object-Oriented Programming）的重要特征。

多态的定义：

多态的实现方式有：

（1）函数重载 

（2）运算符重载 

（3）模版  

（4）虚函数

前三种我们称为静态绑定，第四种称为动态绑定。

静态绑定：绑定过程出现在编译阶段，在编译期就已确定要调用的函数；

动态绑定：绑定过程工作在运行阶段时执行，在程序运行时才确定将要调用的函数。

（只有通过基类指针或引用调用虚函数才能引发动态绑定）

虚函数的概念：在基类中冠以关键字“virtual”的成员函数。

虚函数的定义：

（1）virtual 函数返回值类型函数名称 （参数列表）

（2）如果一个函数在基类中被声明为虚函数，则他在所有派生类中都是虚函数。

值得注意的是：

虚函数不能声明为静态函数，也不能是友元函数。

基类指针指向派生类对象：

//
//  VF2.cpp
//  C++
//
//  Created by Cheng Sun on 2017/6/21.
//  Copyright © 2017年 Cheng Sun. All rights reserved.
//

#include <stdio.h>
#include <iostream>

using namespace std;

class Base
{
public:
    virtual void Func1()
    {
        cout << "Base::Func1()..." << endl;
    }
    virtual void Func2()
    {
        cout << "Base::Func2()..." << endl;
    }
    void Func3()
    {
        cout << "Base::Func3()..." << endl;
    }
};

class Derived : public Base
{
public:
    /*virtual*/ void Func1()
    {
        cout << "Derived::Func1()..." << endl;
    }
    /*virtual*/ void Func2()
    {
        cout << "Derived::Func2()..." << endl;
    }
    void Func3()
    {
        cout << "Derived::Func3()..." << endl;
    }
};

int main()
{
    Base* p;
    Derived d;
    p = &d; // 基类指针指向派生类对象
    
    p->Func1(); //Func1是虚函数，基类指针指向派生类对象，调用的是派生类对象的虚函数。
    p->Func2();
    p->Func3(); //Func3非虚函数，根据p指针实际类型来调用相应类的成员函数。
    
    return 0;
}
程序运行结果： 

Derived::Func1()...
Derived::Func2()...
Base::Func3()...
Program ended with exit code: 0


虚析构函数

同样的道理，也反映在析构函数的应用上。当基类指针指向派生类对象，我们delete基类指针时，若基类的析构函数的不是虚函数，则只会释放基类对象的内存空间。想要同时释放派生类的内存空间，则需要将析构函数设为虚函数。(同样的，只需要将基类的析构函数设为虚函数，则派生类的析构函数也会自动变成虚函数。)

//
//  VF2.cpp
//  C++
//
//  Created by Cheng Sun on 2017/6/21.
//  Copyright © 2017年 Cheng Sun. All rights reserved.
//

#include <stdio.h>
#include <iostream>

using namespace std;

class Base
{
public:
    virtual void Func1()
    {
        cout << "Base::Func1()..." << endl;
    }
    virtual void Func2()
    {
        cout << "Base::Func2()..." << endl;
    }
    void Func3()
    {
        cout << "Base::Func3()..." << endl;
    }
    Base()
    {
        cout << "Base()..." << endl;
    }
    virtual ~Base()
    {
        cout << "~Base()..." << endl;
    }
};

class Derived : public Base
{
public:
    /*virtual*/ void Func1()
    {
        cout << "Derived::Func1()..." << endl;
    }
    /*virtual*/ void Func2()
    {
        cout << "Derived::Func2()..." << endl;
    }
    void Func3()
    {
        cout << "Derived::Func3()..." << endl;
    }
    Derived()
    {
         cout << "Derived()..." << endl;
    }
    ~Derived()
    {
        cout << "~Derived()..." << endl;
    }
};

int main()
{
    Base* p;
    p = new Derived; // 创建派生类对象的时候，会首先创建它的基类对象
    
    p->Func1();
    
    delete p;
    
    return 0;
}
程序运行结果： 

Base()...
Derived()...
Derived::Func1()...
~Derived()...
~Base()...
Program ended with exit code: 0

如果上面代码中的基类没有将析构函数设为虚函数，那么delete p只会执行～Base()，而不会执行~Derived()。

总的来说，什么时候需要用到虚析构函数呢？如果一个类要作为多态基类，那么就要将析构函数定义为虚函数。

反之，如果一个类不会被任何派生类继承，则没有必要将它的析构函数定义为虚函数。

虚表指针和虚函数表

当一个类包含一个或一个以上的虚函数时，编译器就会为这个类产生一个4个字节（编译器工作在32位的框架下）的虚表指针。

虚函数是通过虚表来实现的。讨论没有覆盖的虚函数的情况没有太多意义，我们讨论一下有覆盖的虚函数的工作机制。当一个派生类继承基类时，若是派生类中出现了基类中同名的虚函数，即发生了所谓的覆盖，那么在派生类的虚函数表中，覆盖的虚函数被放到了原本父类虚函数的位置，没有被覆盖的函数，位置依旧。

虚表指针存放在类对象内部的头四个字节，三大区域都有可能。

虚函数表存放在全局数据区（静态区），因为对每个类，所有该类的对象共用虚表。

 

为方便下面部分代码的理解，这里稍稍介绍一下定义一个函数指针的方法：

返回类型 （*指针名） （函数参数列表）

例如： void （*Fun）(void) 意思是定一个指向返回值为void，函数参数也为void的函数的指针。

 

探讨包含虚函数的基类和派生类的内存模型：

//
//  VF3.cpp
//  C++
//
//  Created by Cheng Sun on 2017/6/21.
//  Copyright © 2017年 Cheng Sun. All rights reserved.
//

#include <stdio.h>
#include <iostream>

using namespace std;

class Base // 4 Bytes (pointer to virtual table) + 4 Bytes (int) = 8 Bytes
{
public:
    virtual void Func1()
    {
        cout << "Base::Func1()..." << endl;
    }
    
    virtual void Func2()
    {
        cout << "Base::Func2()..." << endl;
    }
    
    virtual void Func3()
    {
        cout << "Base::Func3()..." << endl;
    }
    
    int data1_;
};

class Derived : public Base // 4 Bytes (pointer to virtual table) + 4 Bytes (int, data1_) + 4 Bytes (int, data2_) = 12 Bytes
{
public:
    void Func2()
    {
        cout << "Derived::Func2()..." << endl;
    }
    
    void Func3()
    {
        cout << "Derived::Func3()..." << endl;
    }
    
    int data2_;
};

typedef void (*FUNC) (void); //定义一个函数指针，指向一个函数，这函数的类型是 void Fun (void)

int main()
{
    cout << "size of Base = " << sizeof(Base) << endl;
    cout << "size of Derived = " << sizeof(Derived) << endl;
    
    Base b;
    Derived d;
    
    long** p = (long**)&b; //定义一个p, 指向虚表指针的指针
    FUNC fun;
    
    cout << "基类的虚函数表如下： " << endl;
    fun = (FUNC)p[0][0];
    fun(); //函数指针 == 函数地址 == 函数名 ？
    
    fun = (FUNC)p[0][1];
    fun();
    
    fun = (FUNC)p[0][2];
    fun();
    
    cout << "派生类的虚函数表如下： " << endl;
    p = (long**)&d;
    fun = (FUNC)p[0][0];
    fun();
    
    fun = (FUNC)p[0][1];
    fun();
    
    fun = (FUNC)p[0][2];
    fun();
    
    cout << "----------------" << endl;
    Base* pp = &d;
    pp->Func2(); // 基类指针指向派生对象，通过基类指针（或引用）调用派生类虚函数，触发动态绑定
    d.Func2();   // 直接调用，不会触发动态绑定，属于静态绑定
    
    return 0;
}
程序运行结果： 
size of Base = 8
size of Derived = 12
基类的虚函数表如下： 
Base::Func1()...
Base::Func2()...
Base::Func3()...
派生类的虚函数表如下： 
Base::Func1()...
Derived::Func2()...
Derived::Func3()...
----------------
Derived::Func2()...
Derived::Func2()...
Program ended with exit code: 0


多重继承中，包含虚函数的基类和派生类的内存模型：

因为是多重继承，不同于单一继承，所以派生类的虚表指针也不止一个，所以代码中可以访问p[1][n],p[2][n]，而如果是单一继承，则只有p[0][n]。

验证代码如下：

//
//  VF3.cpp
//  C++
//
//  Created by Cheng Sun on 2017/6/21.
//  Copyright © 2017年 Cheng Sun. All rights reserved.
//

#include <stdio.h>
#include <iostream>

using namespace std;

class Base1 // 4 Bytes (pointer to virtual table) + 4 Bytes (int) = 8 Bytes
{
public:
    virtual void Func1()
    {
        cout << "Base1::Func1()..." << endl;
    }
    
    virtual void Func2()
    {
        cout << "Base1::Func2()..." << endl;
    }
    
    virtual void Func3()
    {
        cout << "Base1::Func3()..." << endl;
    }
    
    int data1_ = 1;
};

class Base2 // 4 Bytes (pointer to virtual table) + 4 Bytes (int) = 8 Bytes
{
public:
    virtual void Func1()
    {
        cout << "Base2::Func1()..." << endl;
    }
    
    virtual void Func2()
    {
        cout << "Base2::Func2()..." << endl;
    }
    
    virtual void Func3()
    {
        cout << "Base2::Func3()..." << endl;
    }
    
    int data2_ = 2;
};

class Base3 // 4 Bytes (pointer to virtual table) + 4 Bytes (int) = 8 Bytes
{
public:
    virtual void Func1()
    {
        cout << "Base3::Func1()..." << endl;
    }
    
    virtual void Func2()
    {
        cout << "Base3::Func2()..." << endl;
    }
    
    virtual void Func3()
    {
        cout << "Base3::Func3()..." << endl;
    }
    
    int data3_ = 3;
};

class Derived : public Base1, public Base2, public Base3
// 4 Bytes (pointer to virtual table) * 3 + 4 Bytes (int, data1_) * 3 + 4 Bytes (int, data4_) = 28 Bytes
{
public: // four virtual funcitons in derived class
    void Func2()
    {
        cout << "Derived::Func2()..." << endl;
    }
    
    void Func3()
    {
        cout << "Derived::Func3()..." << endl;
    }
    
    virtual void  Func4()
    {
        cout << "Derived::Func4()... 此函数是派生类特有的哦，只存在派生类覆盖第一个基类的虚表里" << endl;
    }
    int data4_ = 4;
};

typedef void (*FUNC) (void); //定义一个函数指针，指向一个函数，这函数的类型是 void Fun (void)

int main()
{
    cout << "size of Base = " << sizeof(Base1) << endl;
    cout << "size of Derived = " << sizeof(Derived) << endl;
    
    
    long** p;
    FUNC fun;
    int* da;
    
    //既然当一个类包含虚函数时，系统就会为它自动生成一个虚函数表
    //那么一个类就一个表？如果对于继承了好几个基类的派生类呢？
    //如果不是，那么继承了多个基类的派生类有多少个虚表指针？
    cout << "-----------------" << endl;
    cout << "第一个基类的虚函数表如下： " << endl;
    Base1 b1;
    p = (long**)&b1;
    
    fun = (FUNC)p[0][0];
    fun();
    
    fun = (FUNC)p[0][1];
    fun();
    
    fun = (FUNC)p[0][2];
    fun();
    cout << "-----------------" << endl;
    
    da = (int*)p[1];
    cout << "data1_ = " << da << endl;
    
    cout << "-----------------" << endl;
    cout << "第二个基类的虚函数表如下： " << endl;
    Base2 b2;
    p = (long**)&b2;
    
    fun = (FUNC)p[0][0];
    fun();
    
    fun = (FUNC)p[0][1];
    fun();
    
    fun = (FUNC)p[0][2];
    fun();
    
    cout << "-----------------" << endl;
    
    da = (int*)p[1];
    cout << "data2_ = " << da << endl;
    
    cout << "-----------------" << endl;
    cout << "第三个基类的虚函数表如下： " << endl;
    Base3 b3;
    p = (long**)&b3;
    
    fun = (FUNC)p[0][0];
    fun();
    
    fun = (FUNC)p[0][1];
    fun();
    
    fun = (FUNC)p[0][2];
    fun();
    cout << "-----------------" << endl;
    da = (int*)p[1];
    cout << "data3_ = " << da << endl;
    
    cout << "-----------------" << endl;
    
    cout << "派生类的虚函数表如下： " << endl;
    Derived d;
    p = (long**)&d; //定义一个p, 指向虚表指针的指针
    
    fun = (FUNC)p[0][0];
    fun(); //函数指针 == 函数地址 == 函数名 ？
    
    fun = (FUNC)p[0][1];
    fun();
    
    fun = (FUNC)p[0][2];
    fun();
    
    fun = (FUNC)p[0][3];
    fun();
    
    cout << "-----------------" << endl;
    
    // 为什么跳过p[1][n]呢，因为p[1][0]存放的是 data1_,虽然数据成员并没有存在虚表里面，但是派生类因为继承的关系，依然继承了基类里面的数据成员，所以通过指针访问虚表指针进而调用虚函数时，要跳过派生类中继承的基类的数据成员的内存存储空间（位置）
    // 验证一下：
    da = (int*)p[1];
    cout << "data1_ = " << da << " 成员数据并不存放于虚表中" << endl;
    cout << "-----------------" << endl;
    fun = (FUNC)p[2][0];
    fun();
    
    fun = (FUNC)p[2][1];
    fun();
    
    fun = (FUNC)p[2][2];
    fun();
    
    cout << "-----------------" << endl;
    da = (int*)p[3];
    cout << "data2_ = " << da << " 成员数据并不存放于虚表中" << endl;
    //fun = (FUNC)p[2][3];
    //fun();   //报错，说明继承了多个基类的派生类，它里面独有的虚函数，只存在第一个（按声明顺序）继承的基类的虚表中！！！
    
    // 为什么跳过p[1][n]呢，因为p[1][0]存放的是 data2_
    cout << "-----------------" << endl;
    fun = (FUNC)p[4][0];
    fun();
    
    fun = (FUNC)p[4][1];
    fun();
    
    fun = (FUNC)p[4][2];
    fun();
    
    cout << "-----------------" << endl;
    da = (int*)p[5];
    cout << "data3_ = " << da << " 成员数据并不存放于虚表中" << endl;
    cout << "-----------------" << endl;
    da = (int*)p[6];
    cout << "data4_ = " << da << " 成员数据并不存放于虚表中" << endl;
    //fun = (FUNC)p[4][3];
    //fun();  //报错，同理。
    
    return 0;
}

程序运行结果：

size of Base = 8
size of Derived = 28
-----------------
第一个基类的虚函数表如下： 
Base1::Func1()...
Base1::Func2()...
Base1::Func3()...
-----------------
data1_ = 0x1
-----------------
第二个基类的虚函数表如下： 
Base2::Func1()...
Base2::Func2()...
Base2::Func3()...
-----------------
data2_ = 0x2
-----------------
第三个基类的虚函数表如下： 
Base3::Func1()...
Base3::Func2()...
Base3::Func3()...
-----------------
data3_ = 0x3
-----------------
派生类的虚函数表如下： 
Base1::Func1()...
Derived::Func2()...
Derived::Func3()...
Derived::Func4()... 此函数是派生类特有的哦，只存在派生类覆盖第一个基类的虚表里
-----------------
data1_ = 0x1 成员数据并不存放于虚表中
-----------------
Base2::Func1()...
Derived::Func2()...
Derived::Func3()...
-----------------
data2_ = 0x2 成员数据并不存放于虚表中
-----------------
Base3::Func1()...
Derived::Func2()...
Derived::Func3()...
-----------------
data3_ = 0x3 成员数据并不存放于虚表中
-----------------
data4_ = 0x4 成员数据并不存放于虚表中
Program ended with exit code: 0








阿默斯特没有雪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于虚函数的总结
Haward
03-14 365
1.虚函数标志着多态性： 基类和派生类的关系就像父子（老子可以让儿子干事，儿子却不能总是让老子去干事）所以，派生类的指针式不能指向基类的，基类的指针却可以指向派生类，基类指针指向派生类的时候，想要调用同名的派生类函数，就必须在基类中定义成虚函数，在程序运行的时候就可以动态的指向派生类的函数了。 2. 构造函数不能是虚函数： 因为，在构造函数中调用虚函数，实际执行的是父类的对应函数，因为自己还...
vf.rar_虚函数
09-21
虚函数表的原理总结，包括虚函数表的各种细节，比较好的文章
从实用主义深入理解C++虚函数
12-22
记得几个月前看过C++虚函数的问题，当时其实看懂了，近笔试中遇到了虚函数竟然不太确定，所以还是理解的不深刻，所以想通过这篇文章来巩固下。 　装逼一刻： 　近，本人思想发生了巨大的转变，在大学的时候由于...
Unity3D中可重载虚函数的总结1
08-08
重载虚函数：Unity3D中所有控制脚本的基类MonoBehaviour有一些虚函数用于绘制中事件的回调，也可以直接理解为事件函数，例如大家都很清楚的Start
C++实验之多态性和虚函数
11-07
多态性和虚函数
虚函数的一些总结
wind的专栏
04-03 540
虚函数与虚函数表： 1、每个类只有一个虚函数表 如：  class BB { int bb; public: virtual void vfbb() { cout<<"BB::vfbb"<<endl; }; virtual ~BB() { cout<<
虚函数相关内容总结
小拳头的博客
04-12 1479
一、多态的定义 多态可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数。用父类的指针指向子类的实例（对象），然后通过父类的指针调用实际子类的成员函数。 c++多态性是通过虚函数来实现的，只有重写了虚函数的才能算作是体现了c++的多态性。多态的目的是为了接口重用，不论传递过来的究竟是哪个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。   二、虚函数的定义
C++虚函数总结
u013840889的专栏
08-12 433
C++虚函数分析      虚函数是C++多态的重点，也是难点，这也是我个人在学习过程中所体会到的，稍有不慎，就会出错。     虚函数的主要功能就是实现多态，子类继承父类，重写父类的函数从而实现自己的功能。多态的具体实现就是定义父类对象指针，指向子类对象，然后在运行时进行动态绑定，调用同名的不同功能的函数。     在C++中，有些概念总是容易混淆，例如：重载，覆盖，隐藏，这些术
虚函数学习总结
liuluan03161009的博客
10-17 183
虚函数是针对动态多态性设计的。什么是动态多态性呢？动态多态性是指程序运行时，不在编译时确定用哪个函数，而是在程序在运行过程中才动态地确定操作所针对的对象。这一过程需要通过虚函数来实现。 虚函数，就是在基类中声明此函数是虚拟的，并不是实际存在的函数，在派生类中，需要使用的时候再重新定义此函数。 虚函数的作用就是允许在派生类中重新定义与基类中完全重名的函数，并且允许通过基类指针或引用来访问基类和派生类中的通明函数。 1.虚函数的声明： virtual void display(){ //virtua关
虚函数知识点总结
奇蠢无比の二琦的博客
06-23 583
一、虚函数的定义 c++中的虚函数时定义在基类中的函数，子类必须对其进行覆盖。在类中声明（无函数体的形式叫做声明） 虚函数的格式： virtual void display（）； 二、虚函数的作用 1.定义子类对象，并且可以调用对象中未被子类覆盖的积累函数A同时在A中，又调用了已被子类覆盖的基类函数B。这样的话，我们这个时候就会调用到基类中的函数B，可我们本来应该调用的时子类中的覆盖函数B。如此，...
关于C++中虚函数的总结
dingzc1234的专栏
12-02 276
#include          #include          usingnamespace std; class Student {          public :                    Student(string , int);                    void display();          protected:
C++虚函数与多态总结
xuzhan666的博客
06-29 260
一、虚函数和动态联编冠以关键字virtual的成员函数称为虚函数实现运行时多态的关键首先是要说明虚函数，另外，必须用基类指针调用派生类的不同实现版本#include&lt;iostream&gt;using namespace std ;class  Base{ public :       Base(char xx)  { x = xx; }                      virtu...
c++虚函数的使用方法
热门推荐
奋斗在路上
05-08 3万+
虚函数的使用方法： （1）在基类用virtual声明成员函数为虚函数。这样就可以在派生类中重新定义此函数，为它赋予新的功能，并能方便被调用。 在类外定义虚函数时，不必在定义virtual （2）在派生类中重新定义此函数，要求函数名，函数类型，函数参数个数和类型全部与基类的虚函数相同，并根据派 生类的需要重新定义函数体。 c++规定，当一个成员函数被声明为虚函数后，其派生类的
虚函数详解
程序员小明
10-04 7987
一、什么是虚函数 类的成员函数前加 virtual 这种函数就叫做虚函数 二、和虚函数相关的一些概念 1、纯虚函数：在虚函数的声明的后面添加=0,这种虚函数就叫纯虚函数。可以不实现，但如果实现必须在类外（只能在父类的构造函数、析构函数中调用） 2、抽象类：成员函数中有纯虚函数，这种类叫抽象类，抽象类不能实例化（不能创建对象），抽象类必须被继承且纯虚函数被覆盖后，由子类实例化对象，如果继承抽象类，但...
虚函数表和虚函数指针
最新发布
09-05
总结起来，虚函数表是一张存储了虚函数地址的表格，属于类而不是对象。虚函数指针是指向虚函数表的指针，位于对象的内存布局的最前端。通过虚函数指针，对象可以在运行时动态地调用正确的虚函数。<span class="em">1...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值