（P34）虚函数与多态：多态 ，静态绑定与动态绑定 ，虚函数 ，虚表指针 ，object slicing与虚函数 ，overload，override，overwrite

2024-06-08 06:08
文章标签 动态 函数 指针 object 绑定 静态 多态 override overload slicing overwrite p34 虚表

本文主要是介绍（P34）虚函数与多态：多态 ，静态绑定与动态绑定 ，虚函数 ，虚表指针 ，object slicing与虚函数 ，overload，override，overwrite，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

    • 1.多态
    • 2.静态绑定与动态绑定
    • 3.虚函数
    • 4.虚表指针
    • 5.object slicing与虚函数
    • 6.overload、override、overwrite
    • 7.通过引用实现多态

1.多态

  • 多态性是面向对象程序设计的重要特征之一
  • 多态性是指发出同样的消息被不同类型的对象接收时，有可能导致完全不同的行为
    （1）调用同名的函数导致不同的行为
    （2）以一致的观点来看待，从同一个基类派生下来的所有派生类对象，减轻了我们分别设计的负担
  • 多态的实现：
    （1）函数重载：调用同名的函数，静态绑定
    （2）运算符重载，静态绑定
    （3）模板，静态绑定
    （4）虚函数：虚函数是动态绑定的

2.静态绑定与动态绑定

  • 静态绑定
    绑定过程出现在编译阶段，在编译期就已经确定要调用的函数；
  • 动态绑定
    绑定过程工作在程序运行时执行，在程序运行时才确定将要调用的函数；
    动态绑定是通过虚函数来实现的；

3.虚函数

  • 虚函数的概念：在基类中冠以关键字virtual的成员函数
  • 虚函数的定义：
    如果一个函数在基类中被声明为虚函数，则他在所有派生类中都是虚函数
virtual 函数类型 函数名称(参数列表)

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

  • 虚函数不能声明为静态的，也不能是友元函数，只能是成员函数
    因为静态函数没有this指针，因为静态函数是类共享的，就不是对象的一部分，就没有办法逐对象的头4个字节vptr虚表指针，进而也没办法找到虚表，所以静态函数不能声明为虚的

  • eg：P34\01.cpp

//演示动态绑定的语法的eg
#include <iostream>
using namespace std;class Base
{
public:virtual void Fun1(){cout<<"Base::Fun1 ..."<<endl;}virtual void Fun2(){cout<<"Base::Fun2 ..."<<endl;}void Fun3(){cout<<"Base::Fun3 ..."<<endl;}
};class Derived : public Base
{
public://void Fun1()没有virtual关键字，Fun1也是虚函数，Fun2类似virtual void Fun1(){cout<<"Derived::Fun1 ..."<<endl;}virtual void Fun2(){cout<<"Derived::Fun2 ..."<<endl;}void Fun3(){cout<<"Derived::Fun3 ..."<<endl;}
};int main(void)
{//基类指针指向派生类对象Base* p;Derived d;p = &d;//调用的是基类的Fun1还是派生类的Fun1是在运行期时决定的p->Fun1();//Fun1是虚函数，基类的指针指向派生类对象，调用的是派生类对象的虚函数p->Fun2();p->Fun3();//Fun3是非虚函数，根据p指针实际类型来调用相应类的成员函数return 0;
}

  • 测试：
    基类指针指向派生类对象，调用的是虚函数时，调用实际所指向的虚函数；
    如果是普通的函数，会依据指针类型来确定调用的函数；
    在这里插入图片描述

  • eg：P34\02.cpp

#include <iostream>
using namespace std;class Base
{
public:virtual void Fun1(){cout<<"Base::Fun1 ..."<<endl;}virtual void Fun2(){cout<<"Base::Fun2 ..."<<endl;}void Fun3(){cout<<"Base::Fun3 ..."<<endl;}Base(){cout<<"Base ..."<<endl;}~Base(){cout<<"~Base ..."<<endl;}
};class Derived : public Base
{
public://void Fun1()没有virtual关键字，Fun1也是虚函数，Fun2类似/*virtual*/ void Fun1(){cout<<"Derived::Fun1 ..."<<endl;}/*virtual*/ void Fun2(){cout<<"Derived::Fun2 ..."<<endl;}void Fun3(){cout<<"Derived::Fun3 ..."<<endl;}Derived(){cout<<"Derived ..."<<endl;}~Derived(){cout<<"~Derived ..."<<endl;}
};int main(void)
{//基类指针指向派生类对象Base* p;p = new Derived;//先构造基类，再构造派生类p->Fun1();//这里派生类的析构函数不会调用，是因为它认为释放的类型是Base*类型，所以只会调用基类的析构函数，因为析构函数不是虚的；//若析构函数是虚的，它认为p所指向的类型是派生类，也就是说p是一个派生类的对象，派生类的释放会先调用基类的析构函数，再调用派生类的析构函数；delete p;return 0;
}

  • 测试：
    析构函数也可以虚的eg
    这里派生类的析构函数不会调用，是因为它认为释放的类型是Base*类型，所以只会调用基类的析构函数，因为析构函数不是虚的；
    若析构函数是虚的，它认为p所指向的类型是派生类，也就是说p是一个派生类的对象，派生类的释放会先调用基类的析构函数，再调用派生类的析构函数；
    在这里插入图片描述

  • 何时需要虚析构函数？

  • 当你可能通过基类指针删除派生类对象时，如果没有将基类的析构函数定义为虚析构函数，那么它只会调用基类的析构函数，而不会调用派生类的析构函数，这样就有可能存在内存泄漏的风险

  • 如果你打算允许其他人通过基类指针调用对象的析构函数（通过delete这样做是正常的），并且被析构的对象是有重要的析构函数的派生类的对象，就需要让基类的析构函数作为虚函数。

  • P34\02.cpp

#include <iostream>
using namespace std;class Base
{
public:virtual void Fun1(){cout<<"Base::Fun1 ..."<<endl;}virtual void Fun2(){cout<<"Base::Fun2 ..."<<endl;}void Fun3(){cout<<"Base::Fun3 ..."<<endl;}Base(){cout<<"Base ..."<<endl;}//什么时候用到虚析构函数？//如果一个类要做为多态基类，要将析构函数定义为虚函数，防止内存泄漏virtual ~Base(){cout<<"~Base ..."<<endl;}
};class Derived : public Base
{
public://void Fun1()没有virtual关键字，Fun1也是虚函数，Fun2类似/*virtual*/ void Fun1(){cout<<"Derived::Fun1 ..."<<endl;}/*virtual*/ void Fun2(){cout<<"Derived::Fun2 ..."<<endl;}void Fun3(){cout<<"Derived::Fun3 ..."<<endl;}Derived(){cout<<"Derived ..."<<endl;}//基类的析构函数是虚函数，派生类的自然也变成虚的~Derived(){cout<<"~Derived ..."<<endl;}
};int main(void)
{//基类指针指向派生类对象Base* p;p = new Derived;//先构造基类，再构造派生类p->Fun1();delete p;return 0;
}
  • 测试：
    在这里插入图片描述

4.虚表指针

  • 虚函数的动态绑定是通过虚表来实现的

  • 包含虚函数的类的头4个字节存放指向虚表的指针，即：虚表指针指向虚表

  • eg：P34\03.cpp

#include <iostream>
using namespace std;class Base
{
public:virtual void Fun1(){cout<<"Base::Fun1 ..."<<endl;}virtual void Fun2(){cout<<"Base::Fun2 ..."<<endl;}int data1_;
};//派生类有3个虚函数
class Derived : public Base
{//会覆盖基类的虚函数Fun2()void Fun2(){cout<<"Derived::Fun2 ..."<<endl;}virtual void Fun3(){cout<<"Derived::Fun3 ..."<<endl;}int data2_;
};//使用typedef来定义一个类型
typedef void (*FUNC)();
int main(void)
{cout<<sizeof(Base)<<endl;cout<<sizeof(Derived)<<endl;Base b;long** p = (long**)&b;//p[0][0]指向基类的虚函数Base::Func1FUNC fun = (FUNC)p[0][0];//将p[0][0]指针强制转换为func，强制转换为函数指针类型fun();//会调用到基类的虚函数Derived d;p = (long**)&d;fun = (FUNC)p[0][0];fun();fun = (FUNC)p[0][1];fun();fun = (FUNC)p[0][2];fun();//只有通过基类指针或者基类引用，才有动态绑定//基类指针pp指向派生类对象，会取出对象d的头4个字节，指向虚表，然后从虚表中找到对应的Func2，实施动态绑定//调用Func2进行偏移，偏移到Derived::Fun2,而不是Base::Fun2,结合派生类内存图去看//pp虽然是基类指针类型，但是调用的是派生类的虚函数Base* pp = &d;pp->Fun2();//Func2是虚函数，运行时期才会去确定Func2的入口地址//虚函数可以直接使用，但不是动态绑定，入口地址在编译期就决定了//直接调用是静态绑定d.fun2();return 0;
}

  • 分析
    （1）虚表与虚基类表不一样，虚基类表再虚继承的时候会产生
    基类与派生类的内存模型
    （2）基类大小为什么是8？因为头四个字节存放的是虚表指针(指向虚表的指针)，4个字节，所以4（基类只有一个数据成员）+4=8
    （3）基类的内存模型，如下：
    Base类中第一个位置存放的是指针，所以地址是指针的指针，存放的是指针，该指针指向了一张表格；
    虚表vtbl中存放的是函数指针；
    虚表里面有2个虚函数
    在这里插入图片描述
    （4）派生类的内存模型，如下：
    虚表里面有3个虚函数
    在这里插入图片描述

  • 测试，验证如下：

在这里插入图片描述

5.object slicing与虚函数

  • object slicing，对象切割，在向上转型的过程中存在对象切割的问题，即派生类特有的成员消失了
  • eg：P34\04.cpp
#include <iostream>
using namespace std;class CObject
{
public:virtual void Serialize(){cout<<"CObject::Serialize ..."<<endl;}
};class CDocument : public CObject
{
public:int data1_;void func(){cout<<"CDocument::func ..."<<endl;Serialize();}//覆盖基类的虚函数virtual void Serialize(){cout<<"CDocument::Serialize ..."<<endl;}//因为要调用派生类CMyDoc的默认构造函数，也要调用基类CDocument的默认构造函数，所以这里需要定义下//因为CMyDoc类中构造函数初始化列表中并没有给出构造函数，也就没有给出基类的构造，所以需要定义基类的默认构造函数CDocument(){cout<<"CDocument"<<endl;}CDocument(const CDocument& other){cout<<"CDocument(const CDocument& other)"<<endl;}
};//继承func，覆盖CDocument类的Serialize
class CMyDoc : public CDocument
{
public:int data2_;//派生类对象覆盖了上面的基类虚函数virtual void Serialize(){cout<<"CMyDoc::Serialize ..."<<endl;}
};int main()
{//都是最底层的派生类对象CMyDoc mydoc;CMyDoc* pmydoc = new CmyDoc;//定义一个对象，指向派生类对象cout<<"#1 testing"<<endl;mydoc.func();//从实际对象的虚表去查找，找到派生类对应的虚函数cout<<"#2 testing"<<endl;((CDocument*)(&mydoc))->func();//((CDocument*)(&mydoc))相当于基类指针指向派生类对象//由于CMyDoc没有重定义func，所以会调用CDocument中的func//实际指向的对象是mydoc，所以会调用CMyDoc中的Serializecout<<"#3 testing"<<endl;pmydoc->func();cout<<"#4 testing"<<endl;((CDocument)mydoc).func();//mydoc对象强制转化为CDocument对象，向上转型//完完全全将派生类对象转化为基类对象，包括虚表都已经发生了改变，都是CDocument虚表了//向上转型会调用构造函数，这里调用拷贝构造函数，将派生类mydoc对象拷贝构造为CDocument类对象，若没写，所以会//调用默认的拷贝构造函数return 0;
}

该eg源自MFC框架
在这里插入图片描述

  • 测试：
    在这里插入图片描述

6.overload、override、overwrite

  • 成员函数被重载overload的特征
    （1）相同的范围（在同一个类中）
    （2）函数名字相同
    （3）参数不同
    （4）virtual关键字可有可无
  • override覆盖是指派生类函数覆盖基类函数，特征是
    （1）不同的范围（分别位于派生类与基类）
    （2）函数名字相同
    （3）参数相同，返回值相同，完全相同
    （4）基类函数必须有virtual关键字
  • overwrite重定义(派生类与基类)
    （1）不同的范围（分别位于派生类与基类）
    （2）函数名与参数都相同，无virtual关键字
    （3）函数名相同，参数不同，virtual可有可无

7.通过引用实现多态

  • eg：
#include <iostream>#include <cstdio>class Object {std::string type_name;protected:explicit Object(std::string const& type_name) : type_name(type_name) {};public:Object() : type_name("Object") {};Object(Object const& other) : type_name(other.type_name) {};virtual void print() { std::cout << type_name; };virtual ~Object() {};};class Door : public Object {std::string handle;public:Door() : Object("Door"), handle("normal") {}explicit Door(std::string const& handle) : Object("Door"), handle(handle) {}Door(Door const& other) : Object(other.handle), handle(other.handle) {}virtual void print() { Object::print(); std::cout << " " << handle << std::endl; }virtual ~Door() {}};class Book : public Object {std::string title;std::string author;public:Book() : Object("Book"), title(), author() {}Book(std::string author, std::string title) : Object("Book"), author(author), title(title) {}Book(Book const& other) : Object(other.title), title(other.title), author(other.author) {}virtual void print() { Object::print(); std::cout << " " << title << " by " << author << std::endl; }virtual ~Book() {}};void print(Object& object) {object.print();}int main(int argc, const char* argv[]){Object object;Door door("simple");Book book("program", "C++");print(object);std::cout << std::endl;print(door);print(book);system("pause");}
  • 测试：
    在这里插入图片描述

说明：

 int & r = i;
在背后的实现可能为底层引用其实是根据指针const 来塑模
int * const ptr = &i;
  • 参考：通过引用实现C++多态

这篇关于（P34）虚函数与多态：多态 ，静态绑定与动态绑定 ，虚函数 ，虚表指针 ，object slicing与虚函数 ，overload，override，overwrite的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1041387。

相关文章

VUE动态绑定class类的三种常用方式及适用场景详解

VUE动态绑定class类的三种常用方式及适用场景详解

《VUE动态绑定class类的三种常用方式及适用场景详解》文章介绍了在实际开发中动态绑定class的三种常见情况及其解决方案,包括根据不同的返回值渲染不同的class样式、给模块添加基础样式以及根据设... 目录前言1.动态选择class样式（对象添加：情景一）2.动态添加一个class样式（字符串添加：情
阅读更多...
SpringCloud配置动态更新原理解析

SpringCloud配置动态更新原理解析

《SpringCloud配置动态更新原理解析》在微服务架构的浩瀚星海中,服务配置的动态更新如同魔法一般,能够让应用在不重启的情况下,实时响应配置的变更,SpringCloud作为微服务架构中的佼佼者,... 目录一、SpringBoot、Cloud配置的读取二、SpringCloud配置动态刷新三、更新@R
阅读更多...
Oracle的to_date()函数详解

Oracle的to_date()函数详解

《Oracle的to_date()函数详解》Oracle的to_date()函数用于日期格式转换,需要注意Oracle中不区分大小写的MM和mm格式代码,应使用mi代替分钟,此外,Oracle还支持毫... 目录oracle的to_date()函数一.在使用Oracle的to_date函数来做日期转换二.日
阅读更多...
深入探讨Java 中的 Object 类详解(一切类的根基)

深入探讨Java 中的 Object 类详解(一切类的根基)

《深入探讨Java中的Object类详解(一切类的根基)》本文详细介绍了Java中的Object类,作为所有类的根类,其重要性不言而喻,文章涵盖了Object类的主要方法,如toString()... 目录1. Object 类的基本概念1.1 Object 类的定义2. Object 类的主要方法3. O
阅读更多...
如何用Python绘制简易动态圣诞树

如何用Python绘制简易动态圣诞树

《如何用Python绘制简易动态圣诞树》这篇文章主要给大家介绍了关于如何用Python绘制简易动态圣诞树,文中讲解了如何通过编写代码来实现特定的效果,包括代码的编写技巧和效果的展示,需要的朋友可以参考... 目录代码：效果：总结 代码：import randomimport timefrom math
阅读更多...
Java中JSON字符串反序列化(动态泛型)

Java中JSON字符串反序列化(动态泛型)

《Java中JSON字符串反序列化(动态泛型)》文章讨论了在定时任务中使用反射调用目标对象时处理动态参数的问题,通过将方法参数存储为JSON字符串并进行反序列化,可以实现动态调用,然而,这种方式容易导... 需求：定时任务扫描，反射调用目标对象，但是，方法的传参不是固定的。方案一：将方法参数存成jsON字
阅读更多...
C++11的函数包装器std::function使用示例

C++11的函数包装器std::function使用示例

《C++11的函数包装器std::function使用示例》C++11引入的std::function是最常用的函数包装器,它可以存储任何可调用对象并提供统一的调用接口,以下是关于函数包装器的详细讲解... 目录一、std::function 的基本用法1. 基本语法二、如何使用 std::function
阅读更多...
.NET利用C#字节流动态操作Excel文件

.NET利用C#字节流动态操作Excel文件

《.NET利用C#字节流动态操作Excel文件》在.NET开发中,通过字节流动态操作Excel文件提供了一种高效且灵活的方式处理数据,本文将演示如何在.NET平台使用C#通过字节流创建,读取,编辑及保... 目录用C#创建并保存Excel工作簿为字节流用C#通过字节流直接读取Excel文件数据用C#通过字节
阅读更多...
第10章 中断和动态时钟显示

第10章 中断和动态时钟显示

第10章 中断和动态时钟显示 从本章开始，按照书籍的划分，第10章开始就进入保护模式（Protected Mode）部分了，感觉从这里开始难度突然就增加了。 书中介绍了为什么有中断（Interrupt）的设计，中断的几种方式：外部硬件中断、内部中断和软中断。通过中断做了一个会走的时钟和屏幕上输入字符的程序。 我自己理解中断的一些作用： 为了更好的利用处理器的性能。协同快速和慢速设备一起工作
阅读更多...
hdu1171（母函数或多重背包）

hdu1171（母函数或多重背包）

题意：把物品分成两份，使得价值最接近 可以用背包，或者是母函数来解，母函数（1 + x^v+x^2v+.....+x^num*v）（1 + x^v+x^2v+.....+x^num*v）（1 + x^v+x^2v+.....+x^num*v） 其中指数为价值，每一项的数目为（该物品数+1）个 代码如下： #include<iostream>#include<algorithm>
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2