（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。

相关文章

第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>
阅读更多...
动态规划---打家劫舍

动态规划---打家劫舍

题目： 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。 思路： 动态规划五部曲： 1.确定dp数组及含义 dp数组是一维数组，dp[i]代表
阅读更多...
代码随想录冲冲冲 Day39 动态规划Part7

代码随想录冲冲冲 Day39 动态规划Part7

198. 打家劫舍 dp数组的意义是在第i位的时候偷的最大钱数是多少 如果nums的size为0 总价值当然就是0 如果nums的size为1 总价值是nums[0] 遍历顺序就是从小到大遍历 之后是递推公式 对于dp[i]的最大价值来说有两种可能 1.偷第i个 那么最大价值就是dp[i-2]+nums[i] 2.不偷第i个 那么价值就是dp[i-1] 之后取这两个的最大值就是d
阅读更多...
C++操作符重载实例(独立函数)

C++操作符重载实例(独立函数)

C++操作符重载实例，我们把坐标值CVector的加法进行重载，计算c3=c1+c2时，也就是计算x3=x1+x2，y3=y1+y2，今天我们以独立函数的方式重载操作符+（加号），以下是C++代码： c1802.cpp源代码： D:\YcjWork\CppTour>vim c1802.cpp #include <iostream>using namespace std;/*** 以独立函数
阅读更多...
函数式编程思想

函数式编程思想

我们经常会用到各种各样的编程思想，例如面向过程、面向对象。不过笔者在该博客简单介绍一下函数式编程思想. 如果对函数式编程思想进行概括，就是f(x) = na(x) , y=uf(x)…至于其他的编程思想，可能是y=a(x)+b(x)+c(x)…，也有可能是y=f(x)=f(x)/a + f(x)/b+f(x)/c… 面向过程的指令式编程 面向过程，简单理解就是y=a(x)+b(x)+c(x)
阅读更多...
Thymeleaf：生成静态文件及异常处理java.lang.NoClassDefFoundError: ognl/PropertyAccessor

Thymeleaf：生成静态文件及异常处理java.lang.NoClassDefFoundError: ognl/PropertyAccessor

我们需要引入包： <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-thymeleaf</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>sp
阅读更多...
SpringMVC入参绑定特别注意

SpringMVC入参绑定特别注意

1.直接在controller中定义一个变量，但是此种传输方式有一个限制就是参数名和请求中的参数名必须保持一致，否则失效。 @RequestMapping("test2")@ResponseBodypublic DBHackResponse<UserInfoVo> test2(String id , String name){UserInfoVo userInfoVo = new UserInf
阅读更多...
【C++学习笔记 20】C++中的智能指针

【C++学习笔记 20】C++中的智能指针

智能指针的功能 在上一篇笔记提到了在栈和堆上创建变量的区别，使用new关键字创建变量时，需要搭配delete关键字销毁变量。而智能指针的作用就是调用new分配内存时，不必自己去调用delete，甚至不用调用new。 智能指针实际上就是对原始指针的包装。 unique_ptr 最简单的智能指针，是一种作用域指针，意思是当指针超出该作用域时，会自动调用delete。它名为unique的原因是这个
阅读更多...
JavaSE——封装、继承和多态

JavaSE——封装、继承和多态

1. 封装 1.1 概念      面向对象程序三大特性：封装、继承、多态 。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节 。     比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器， USB 插孔等，让用户来和计算机进行交互，完成日常事务。但实际上：电脑真正工作的却是CPU 、显卡、内存等一些硬件元件。
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2