C++ 多态-CSDN博客

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6

前言

本文将会向你介绍多态的概念重写虚表纯虚函数等知识点

多态的概念

多态是在不同继承关系的类对象去调用同一函数产生了不同的行为。比如Student继承了Person。Person对象买票全价Student对象买票半价。
那么在继承中要构成多态还有两个条件

  1. 必须通过基类的指针或者引用调用虚函数
  2. 被调用的函数必须是虚函数且派生类必须对基类的虚函数进行重写重写的概念会在下文介绍
class Person {
public:
       virtual void BuyTicket()
       {
              cout << "Person::买票-全价" << endl;
       }
       virtual ~Person()
       {
              cout << "~Person()" << endl;
       }
};
class Student : public Person {
public:
       //重写
       void BuyTicket() { cout << "Student::买票-半价" << endl; }
       ~Student()
       {
              cout << "~Student()" << endl;
       }
};
//父类的引用
void Func(Person& p)
{
       p.BuyTicket();
}
int main()
{
       Person ps;
       Student st;
       Func(ps);
       Func(st);
       return 0;
}

结果如下
在这里插入图片描述
我们可以观察到该多态满足了两个条件
1、通过了父类的引用调用虚函数
2、派生类对父类的虚函数进行了重写

重写

说起重写我们不得不再把上一篇文章中的隐藏再来谈谈
隐藏是指在派生类中定义了与基类中同名的成员函数导致基类中的成员函数被隐藏起来无法直接访问。这种情况下通过派生类的对象只能访问到派生类中定义的同名成员函数。隐藏是静态绑定的即在编译时就确定了调用的是哪个函数。
重写是指派生类中定义了与基类中同名的虚函数通过基类的指针或引用调用该函数时会根据指针或引用所指向的对象的实际类型来确定调用的是基类的函数还是派生类的函数。重写是动态绑定的即在运行时根据对象的实际类型来确定调用的是哪个函数。
总结如下
重定义隐藏
两个函数分别在基类和派生类的作用域
函数名相同两个基类和派生类的同名函数不构成重写就是重定义
重写覆盖
两个函数分别在基类和派生类的作用域
函数名/参数/返回值都必须相同协变除外
两个函数必须是虚函数
以下就是一个隐藏的例子如果派生类的函数与基类的函数同名但是参数不同。此时无论有没有virtual关键字基类的函数都将被隐藏。

class Car
{
public:
	virtual void Drive(int x) 
	{
		cout << "Car::Drive(int x)" << endl;
	}
};
class Benz : public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz::Drive()" << endl;
	};
};

以下依旧是隐藏如果派生类的函数与基类的函数同名而且参数相同但是基类的函数没有virtual关键字此时基类的函数将被隐藏

class Car
{
public:
	void Drive() 
	{
		cout << "Car::Drive()" << endl;
	}
};
class Benz : public Car
{
public:
	void Drive()
	{
		cout << "Benz::Drive()" << endl;
	};
};

以下就是重写了满足1、函数名返回值参数都相同。2、两个函数分别在父类和派生类的作用域里面。3、两个函数都是虚函数的条件

class Car
{
public:
	virtual void Drive() 
	{
		cout << "Car::Drive()" << endl;
	}
};
class Benz : public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz::Drive()" << endl;
	};
};

最后我们可以得到一个结论函数名相同两个基类和派生类的同名函数不构成重写就是重定义
看到这里你应该会有个疑问什么是静态绑定什么又是动态绑定呢

多态的实现原理

多态的实现原理主要涉及两个概念动态绑定和虚函数
动态绑定在编译时编译器并不知道一个对象的具体类型而是根据引用或指针的类型来访问对象的成员。在运行时根据引用或指针所指向的实际对象的类型动态绑定机制会决定调用哪个对象的方法。这样不同类型的对象可以对同一个消息做出不同的响应。
我们回到开头的买票例子

class Person {
public:
       virtual void BuyTicket()
       {
              cout << "Person::买票-全价" << endl;
       }
       virtual ~Person()
       {
              cout << "~Person()" << endl;
       }
};
class Student : public Person {
public:
       //重写
       void BuyTicket() { cout << "Student::买票-半价" << endl; }
       ~Student()
       {
              cout << "~Student()" << endl;
       }
};
//父类的引用
void Func(Person& p)
{
       p.BuyTicket();
}
int main()
{
       Person ps;
       Func(ps);
       ps.BuyTicket();
       return 0;
}

构成多态时->动态绑定

void Func(Person& p)
{
       p.BuyTicket();
}
Func(ps);

在这里插入图片描述

...省略了与当前讨论无关的汇编代码
 p中存的是父类对象的指针将p移动到eax中
00142831 mov eax,dword ptr [p]

[eax]就是取eax值指向的内容这里相当于把对象头4个字节(虚表指针)移动到了edx
00142834 mov edx,dword ptr [eax]

[edx]就是取edx值指向的内容这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
0014283B mov eax,dword ptr [edx]

call eax中存虚函数的指针。这里可以看出满足多态的调用不是在编译时确定的是运行起来
以后到对象的中取找的。
0014283D call eax
0014283F cmp esi,esp

不构成多态->静态绑定

 ps.BuyTicket();

首先BuyTicket虽然是虚函数但是ps是对象不满足多态的条件所以这里是普通函数的调用转换成地址时是在编译时已经从符号表确认了函数的地址直接call 地址
在这里插入图片描述

探索虚表

class Base
{
public:
       virtual void Func1()
       {
              cout << "Func1()" << endl;
       }
       virtual void func2()
       {
              cout << "func2()" << endl;
       }
       void func3()
       {
              cout << "func3()" << endl;
       }
private:
       int _b = 1;
       char _ch;
};
int main()
{
       cout << sizeof(Base) << endl;
       Base b;
       return 0;
}

结果为12字节并不是我们想的int4字节+ char1字节+3字节内存对齐= 8字节
原因是当存在虚函数的时候每个对象都会有一个虚函数表指针vfptr该指针指向一个虚函数表vtable。虚函数表是一个存储了虚函数地址的数组每个虚函数在表中占据一个位置。通过虚函数表指针程序可以在运行时动态地确定调用哪个虚函数。在这里插入图片描述
在这里插入图片描述
对象中的这个指针我们叫做虚函数表指针(v代表virtualf代function)。一个含有虚函数的类中都至少都有一个虚函数表指针因为虚函数的地址要被放到虚函数表中虚函数表也简称虚表那么派生类中这个表放了些什么呢我们接着往下分析

单继承对象模型

class Base {
public:
       virtual void func1() { cout << "Base::func1" << endl; }
       virtual void func2(){ cout << "Base::func2" << endl; }
private:
       int _a;
};

class Derive :public Base {
public:
       //重写了func1
       virtual void func1() { cout << "Derive::func1" << endl; }
       virtual void func3() { cout << "Derive::func3" << endl; }
       virtual void func4() { cout << "Derive::func4" << endl; }
       void func5() { cout << "Derive::func4" << endl; }
private:
       int b;
};
class X :public Derive {
public:
       //重写了func3
       virtual void func3() { cout << "X::func3" << endl; }
};
int main()
{
       Base b;
       Derive d;
       X x;
  //多态
       Derive* p = &d;
       p->func3();
       p = &x;
       p->func3();
       return 0;
}

观察下图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数也可以认为是他的一个小bug。那么我们如何查看d的虚表呢?
在这里插入图片描述
我们可以通过内存窗口观察虚表中的虚函数指针观察箭头指向可以发现虚函数重写后对应的虚函数指针也发生了改变重写/覆盖
在这里插入图片描述
请添加图片描述

多继承对象模型

//多继承的虚表
class Base1 {
public:
       virtual void func1() { cout << "Base::func1" << endl; }
       virtual void func2() { cout << "Base::func1" << endl; }
private:
       int b1;
};
class Base2 {
public:
       virtual void func1() { cout << "Base::func1" << endl; }
       virtual void func2() { cout << "Base::func1" << endl; }
private:
       int b2;
};
class Derive : public Base1, public Base2 {
public:
       //重写了base1的和base2的func1
       virtual void func1()
       {
              cout << "Derive::func1" << endl;
       }
       //自己的虚函数func3放在第一张虚表中
       virtual void func3() { cout << "Derive::func3" << endl; }
private:
       int d1;
};
int main()
{
       Derive d;
       //打印第一张虚表
       PrintVFT((VFUNC*)(*(int*)&d));
       //打印第二张虚表
       PrintVFT((VFUNC*)(*(int*)((char*)&d+sizeof(Base1))));
       return 0;
}

透过监视一栏我们可以观察到对象d中存了两张虚表多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中
在这里插入图片描述
在这里插入图片描述
结论

纯虚函数

定义纯虚函数是在基类中声明的没有实际实现的虚函数。它的声明形式为在函数声明的末尾加上 “= 0”。纯虚函数的目的是为了让派生类必须实现该函数以使派生类能够成为一个完整的类。
特点
1.间接强制取派生类重写
2.具有纯虚函数的类叫做抽象类抽象类-不能实例化出对象
3.派生类若不重写纯虚函数则无法实例化出对象

class  Car
{
public:
	virtual void Drive() = 0;
	void func()
	{
		cout << "void func()" << endl;
	}
};

class Benz : public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz-舒适" << endl;
	};
};

class BMW :public Car
{
public:
	virtual void Drive()
	{
		cout << "BMW-操控" << endl;
	}
};

void func(Car* ptr)
{
	ptr->Drive();
}

int main()
{
	//func(new Benz);
	func(new BMW);
	Benz b;
	b.Drive();
	return 0;
}

若是我们屏蔽了派生类对纯虚函数的重写则无法构建对象
在这里插入图片描述

小结

今日的分享就到这里啦如果本文存在疏漏或错误的地方还请您能够指出

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6
标签: c++
返回列表

上一篇：2023年CCF中国开源大会“大模型时代的智能化软件工程新范式”分论坛成功举行...-CSDN博客

下一篇：ON1 Photo RAW 2024照片编辑器「Mac」-CSDN博客

“C++ 多态-CSDN博客” 的相关文章

C/C++学习路线总结与分享1年前 (2023-02-02)
【C++11】—— 可变参数模板1年前 (2023-02-02)
C++基础语法 3（面向对象、C++在执行过程当中4个区域、引用）1年前 (2023-02-02)
【链表】leetcode142.环形链表II(C/C++/Java/Js)1年前 (2023-02-02)
第十三届蓝桥杯 C++ B 组省赛 F 题——统计子矩阵1年前 (2023-02-02)
C++：高斯坐标，大地坐标转经纬度1年前 (2023-02-02)
C/C++宏定义注意事项1年前 (2023-02-02)
C++设计模式实践——线上购物系统1年前 (2023-02-02)
【图论】「极简复习版」最短路径 Java/C++ 实现1年前 (2023-02-02)
C++设计模式(4)——策略模式1年前 (2023-02-02)

阿里云国际版