ETJava Beta | Java
注册
登录
注册
登录
注册
登录
在函数前加上virtual就是虚函数
class A{
public:
virtual void func(){}; //这是一个虚函数
};
虚函数的继承体现了接口继承
继承了接口等于继承了函数的壳,这个壳有返回值类型,函数名,参数列表,还包括了缺省参数
只需要重写/覆盖接口的实现(函数体)
含有虚函数的类是虚类.
是虚类,且是基类,则是虚基类
三同:函数名,参数(平常说的参数都是说参数的类型,与缺省参数无关),返回值都要相同
重写/覆盖是指该函数是虚函数且函数的名字、类型、返回值完全一样的情况下,子类的函数体会替换掉继承下来的父类虚函数的函数体
体现接口继承
重写/覆盖只有虚函数才有,非虚函数的是隐藏/重定义.注意区别
重写/覆盖只对函数体有效,返回值类型,函数名,参数列表,和缺省参数都不能修改
只要子类写上满足三同的虚函数都会触发重写.无论是否修改函数体
多态有两个条件,任何一个不满足都不能执行多态 ,分别是
多态的基础
class Person {
public:
virtual void BuyTicket() { //是虚函数
std::cout<<"全票"<<std::endl;
}
};
class Student :public Person {
public:
virtual void BuyTicket() { //虚函数的重写
std::cout<<"半票"<<std::endl;
}
};
void func(Person& p){ //父类的指针或引用去调用
p.BuyTicket();
}
int main(){
Person p;
Student s;
func(p);
func(s);
return 0;
}
多态中子类可以不写virtual,而且只要父类是虚函数,之后继承的子孙类都是虚函数(待验证,是否位于虚表)
class Person {
public:
virtual void BuyTicket() {
std::cout << "全票" << std::endl;
}
};
class Student :public Person {
public:
void BuyTicket() {
std::cout << "半票" << std::endl;
}
};
class Children : public Person {
public:
void BuyTicket(){
std::cout << "三折票" << std::endl;
}
};
void func(Person& p){
p.BuyTicket();
}
int main()
{
Person p;
Student s;
Children c;
func(p);
func(s);
func(c);
return 0;
}
说法1:体现接口继承:继承了接口==继承了函数的壳,只需要重写接口的实现(函数体),这样就是体现了接口继承
说法2: 可能存在父类子类不是同一个人实现的情况.
假设子类必须是虚函数才能实现多态,如果父类是虚函数,而另外一个人写子类时忘记加上virtual,这是就有可能发生内存泄露问题,如切片后再析构的情况(只析构父类,不析构子类).
因此,父类是虚函数的情况下,子类不强制需要virtual才能发生多态这种行为,能有一定的安全作用.
缺点:没有统一规范. 最好还是全都加上virtual
概念引入:协变与逆变
协变与逆变规定了编程语言中的类型父子关系的方向
引入这个概念是为了类型安全
协变(父←子)
动物 - 哺乳类 - 熊科 - 黑熊
逆变(子→父)
协变场景下三同中返回值可以不同,且返回值必须是父类或派生类关系的指针或引用
其他方面读者可以阅读更具体的资料
举例1:父类返回类型为父类,子类返回类型为子类
class Person {
public:
virtual Person& BuyTicket() {
std::cout << "全票" << std::endl;
Person p;
return p;
}
};
class Student :public Person {
public:
Student& BuyTicket() {
std::cout << "半票" << std::endl;
Student s;
return s;
}
};
举例2:父类子类返回类型全部是父类
class Person {
public:
virtual Person& BuyTicket() {
std::cout << "全票" << std::endl;
Person p;
return p;
}
};
class Student :public Person {
public:
Person& BuyTicket() {
std::cout << "半票" << std::endl;
Person s;
return s;
}
};
举例3:返回值类型为非所在类类型
class A{};
class B : public A{};
class Person {
public:
virtual A* BuyTicket() {
std::cout << "全票" << std::endl;
return nullptr;
}
};
class Student :public Person {
public:
B* BuyTicket() {
std::cout << "半票" << std::endl;
return nullptr;
}
};
返回值为非虚函数所在类类型,且都是返回父类
注意:
全部返回子类也不支持
返回值类型为非所在类类型的情况也是如此
总之,当虚函数返回值为基类类型的指针或引用时,编译器才会检查是否是协变类型.此时如果派生类虚函数返回值是基类或派生类的指针或引用,则判定为协变;否则不是协变
先看继承关系中直接实例对象的代码
class Person {
public:
~Person() { std::cout << "~Person()" << "\n"; }
};
class Student :public Person {
public:
~Student() { std::cout << "~Student()" << "\n"; }
};
int main(){
Person per;
Student stu;
return 0;
}
结果没有问题,析构执行是正确的
再看指针切片样例
int main(){
Person* ptr1 = new Person;
Person* ptr2 = new Student;
delete ptr1;
delete ptr2;
return 0;
}
结果:
显然,没有正确的析构.
在继承篇有提起过的继承体系中析构函数会被重命名成Destructor.
本意:根据指针(引用)指向的对象类型来选择对应的析构函数
结果:根据指针(引用)的类型的来选择对应的析构函数
虽然结果符合正常语法,但是我们在这种情况下并不希望是这样,我们希望它是根据指针(引用)指向的对象类型来选择对应的函数执行.
而根据指针(引用)指向的对象类型来选择对应的函数，这正好就是多态的理念.
因此,为了解决切片中这样的析构函数问题,我们选择将其转化成多态来解决.
此时我们已经满足多态构造的2个条件的其中之一:基类的指针或引用， 剩下的我们需要满足派生类的析构函数构成对基类析构函数的重写。而重写的条件是：返回值类型，函数名，参数列表都相同。对于析构函数，目前还缺的就是函数名相同，因此,析构函数的名称统一处理为destructor.
析构函数都成为虚函数
class Person {
public:
virtual ~Person() { std::cout << "~Person()" << "\n"; }
};
class Student :public Person {
public:
virtual ~Student() { std::cout << "~Student()" << "\n"; }
};
int main(){
Person* ptr1 = new Person;
Person* ptr2 = new Student;
delete ptr1;
delete ptr2;
return 0;
}
至此,彻底解决继承体系中析构函数问题.
1.以下程序输出结果是什么（）
class A
{
public:
virtual void func(int val = 1){ std::cout<<"A->"<< val <<std::endl;}
virtual void test(){ func();}
};
class B : public A
{
public:
void func(int val=0){ std::cout<<"B->"<< val <<std::endl; }
};
int main(int argc ,char* argv[])
{
B*p = new B;
p->test();
return 0;
}
A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确
B*p = new B;这里p是普通的指针,不满足多态.
p->test();这里调用了继承下来的test();
test()的实际原型是test(A*this),因此函数体内即为(A*)->func();
因为test()在B中,B会将自己的this传参给test(),即父类类型指针接收子类类型指针.同时func也是虚函数.
因此满足多态,即test()中调用的是子类的func().
又因为虚函数的继承是接口继承,只有函数体是子类的,其他都是父类的,缺省参数也是父类的,因此答案是B->1
以下程序输出结果是什么（）
class A
{
public:
virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
};
class B : public A
{
public:
void func(int val = 0) { std::cout << "B->" << val << std::endl; }
virtual void test() { func(); }
};
int main(int argc ,char* argv[])
{
B*p = new B;
p->test();
return 0;
}
A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确
D: B->0
C++11中允许将类标记为final，继承该类会导致编译错误.
用法:直接在类名后面使用关键字final
class A final
{};
class B : public A //编译错误
{};
明确该类未来不会被继承时,可以使用final明确告知.
C++中还允许将函数标记为final，禁用子类中重写该方法
用法:在函数体前使用关键字final
class A {
public:
virtual void func() final {}
};
class B : public A {
public:
void func() {} //编译错误
};
一般情况下,只有最终实现的情况下会使用final： 当你在一个派生类中实现了某个虚函数，并且认为这是该函数的“最终”或“最完善”的实现，不希望后续的派生类再次改变其行为。使用final关键字可以确保这一点，防止函数被进一步重写。
对虚函数使用final后,编译器可以做出一些优化，比如内联调用，因为它知道不会有其他版本的函数存在。
C++对函数重写的要求是比较严格的.如果某些情况因为疏忽而导致函数没有进行重写,这种情况在编译期间是不会报错的,只有程序运行时没有得到预期结果才可能意识到出现了问题,等到这时再debug已经得不偿失了.
因此,C++11提供了override关键字,可以帮助用户检测是否完成重写
override(覆盖)关键字用于检查派生类虚函数是否重写了基类的某个虚函数，如果没有则无法通过编译。
在需要进行重写的虚函数的函数体前或参数列表花括号后加上override
class A {
public:
virtual void func() {}
};
class B : public A {
public:
void func(int i) override{ }
};
在虚函数后面写上=0,这个函数就为纯虚函数.
virtual void fun() = 0;
纯虚函数只能写声明,不能写函数体.
含有纯虚函数的类是纯虚类,更多的是叫抽象类(也叫做接口类)
class A{
virtual void func() = 0;
};
抽象类不能实例化对象
抽象类的派生类如果不重写纯虚函数,则还是抽象类
纯虚函数规范了派生类必须重写,更体现接口继承
纯虚类可以有成员变量
从类中继承的函数包含两部分：一是"接口"(interface)，二是 "实现" (implementation).
接口就是函数的"壳",是函数除了函数体外的所有组成.
实现就是函数的函数体.
纯虚函数 => 继承的是:接口 (interface)
普通虚函数 => 继承的是:接口 + 缺省实现 (default implementation)
非虚成员函数 => 继承的是:接口 + 强制实现 (mandatory implementation)
普通函数的继承是一种实现继承，派生类继承了基类函数，继承的是函数的实现,目的是为了复用函数实现.
普通虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口+缺省实现，目的是为了重写，达成多态.
纯虚函数只继承了接口,要求用户必须要重写函数的实现.
如果不实现多态，不要把函数定义成虚函数。
计算下面虚类的大小
class Base{
public:
virtual void func() {}
private:
int _a;
char _b;
};
int main(int argc, char* argv[])
{
std::cout<<sizeof(Base)<<"\n";
return 0;
}
结果:
如果是一般的类,那我们会认为是计算结构体对齐之后的大小,结果应当是8.
但计算结果发现,虚类的结果是12,说明虚类比普通类多了一些东西.
实例化对象Base b;查看监视窗口
可以发现对象的头部多了一个指针_vfptr;这个指针叫做虚函数表指针,它指向了虚函数表
指向虚表的指针,叫虚函数表指针,位于对象的头部.
定义:
如果在类中定义了虚函数,则对象中会增加一个隐藏的指针,叫虚函数表指针__vfptr,虚函数表指针在成员的前面,直接占了4/8字节.
虚函数表指针所指向的表,叫做虚函数表(virtual function table),也叫做虚表
虚函数表本质是一个虚函数指针数组.元素顺序取决于虚函数的声明顺序.大小由虚函数的数量决定.
虚表在编译期间生成.
虚表是由虚函数的地址组成,而编译期间虚函数的地址已经存在,因此能够在编译期间完成.
虚函数继承体系中,虚基类先生成一份虚表,之后派生类自己的虚表都是基于从父类继承下来的虚表.
特例,为了方便使用,VS在虚表数组最后面放了一个nullptr.(其他编译器不一定有)
class Person {
public:
virtual void BuyTicket(int val = 1) {
std::cout << "全票" << ":" << val << "\n";
}
virtual void func(int val = 1) {
std::cout << "全票" << ":" << val << "\n";
}
};
class Student :public Person {
public:
void BuyTicket(int val = 0) { //覆盖
std::cout << "半票" << "=" << val << "\n";
}
};
int main() {
Person p;
Student s;
return 0;
}
注:虚表指针和成员谁先初始化由编译器决定
虚表没有明确说必须在哪里,不过我们可以尝试对比各个区的地址,看虚表的大致位置
class Base{
public:
virtual void func(){
}
private:
int _a;
};
class Derive :public Base {
};
int main()
{
Base b;
Derive d;
int x = 0;
int *y = new int;
static int z = 1;
const char * str = "hello world";
printf("栈对象地址: %p\n",&x);
printf("堆对象地址: %p\n",y);
printf("静态区对象地址: %p\n",&z);
printf("常量区对象地址: %p\n",str);
printf("Base对象虚表指针: %p\n",*(int**)(&b)); //32位环境
printf("Derive对象虚表指针:%p\n",*(int**)(&d));
return 0;
}
根据地址分析,虚表指针与常量区对象地址距离最近,因此可以推测虚表位于常量区.
另外,在监视窗口中观察虚表指针与虚函数地址也可以发现,虚表指针与虚函数地址也是比较接近,也可以大致推测在代码段中.(代码段常量区很贴近,比较ambiguous,模棱两可的)
从应用角度来说,虚表也应当位于常量区中,因为虚表在编译期间确定好后,不会再发生改变,在常量区也是比较合适的.
我们可以使用子类对象给父类类型赋值,但要注意C++中不支持通过对象切片实现多态.
首先赋值过程会涉及大量拷贝.成本开销比较大.
其次,拷贝只拷贝成员,不会拷贝虚表.
因为子类中继承的自父类的虚表可能被子类覆盖过,如果切片给父类对象,那么父类对象的虚表中就会有子类重写的虚函数,显然不合理.
多态是怎么实现的,其实程序也不知道自己调用的是子类还是父类的,在它眼里都是一样的父类指针或引用.
如果是虚函数,则在调用时,会进入到"父类"中去,找到虚函数表中的函数去调用,是父类的就调用父类的,是子类就调用子类的.如果不是虚函数,则直接调用.
多态的实际原理也是传什么调什么,编译期间虚函数表已经确定好了
再看多态的两个条件
为什么需要虚函数重写,虚表中存的就是子类的虚函数,重写后就和父类不同了,也就能实现多态的效果.
为什么需要父类的指针或引用,就是因为指针或引用既能指向父类也能指向子类,能够实现切片,区分父类和子类
虚函数覆盖这个词的由来就是,子类重写的虚函数会覆盖父类的.
覆盖是原理层的叫法.重写是语法的叫法
class Person {
public:
virtual void BuyTicket(int val = 1) {
std::cout << "全票" << ":" << val << "\n";
}
virtual void func(int val = 1) {
std::cout << "全票" << ":" << val << "\n";
}
};
class Student :public Person {
public:
void BuyTicket(int val = 0) {
std::cout << "半票" << "=" << val << "\n";
}
virtual void Add()
{
std::cout<<"Studetn"<<"\n";
}
};
class C : public Student {
public:
virtual void Add()
{
std::cout<<"C"<<"\n";
}
int _c = 3;
};
void fun(Student &s){
s.Add();
}
int main() {
Person p;
Student s;
C c;
fun(c);
return 0;
}
对上例函数查看VS监视时,发现虚表不显示完全
需要在监视窗口中手动输入(void**)0x虚函数表指针,10,表示以(void*)[10]方式展开
此后就能全部显示虚表了
(仅适用VS,因为VS会将虚表末尾置空,如果是g++,则需要明确虚表有几个虚函数)
class A {
public:
virtual void fun1(){
std::cout<<"func1()"<<"\n";
}
virtual void fun2(){
std::cout<<"func2()"<<"\n";
}
};
class B :public A {
public:
virtual void fun3(){
std::cout<<"func3()"<<"\n";
}
};
using VFPTR = void(*)(void);
void PrintVFTable(VFPTR table[])
{
for (int i = 0; table[i]; i++)
{
//1.打印虚类对象的虚表
printf("%p",table[i]);
//2.指针不够直观的情况下.可以执行函数指针得到更具象的结果
VFPTR f = table[i];
f();
//小细节:f()能够正常执行,说明这样的调用方式能够自动将虚表所在对象的this传参到虚函数中.
}
}
int main()
{
A a;
B b;
PrintVFTable((VFPTR*)(*((VFPTR*)&a))); //方式1 (修改,VFPTR*比int*更通用)
puts("");
PrintVFTable(*(VFPTR**)&b); //方式2 ,在明确指向逻辑的情况下,二级指针更为简洁
/* 代码理解:
1.typedef和using语法层面功能都是将类型重命名,这个重命名会被认定成一个新类型,需要时再进行解释.
2.int*在32位和64位下解引用都是4字节.而指针大小在32位下是4字节,64位下是8字节.在64位机器下使用int*解引用的话,就会得到错误的结果.因此int*不够普遍.
3.VFPTR被当作一个新类型来看待.直接使用VFPTR时,编译器认为是非指针变量;使用VFPTR*时,编译器认为是一级指针变量.(VFPTR*)&a即为将a的地址转成类型为VFPTR的一级指针.之后,解引用则以VFPTR的大小为步长,取出相应的数据(虚表指针,也是虚表首地址).VFPTR实际类型为函数指针,32位下为4字节,64位下为8字节,因此解引用后能够取得正确的结果.
*/
return 0;
}
模型图
先看虚函数多继承体系下内存布局
class Base1 {
public:
virtual void func1() { std::cout << "Base1::func1" <<std::endl; }
virtual void func2() { std::cout << "Base1::func2" << std::endl; }
private:
int b1 = 1;
};
class Base2 {
public:
virtual void func1() { std::cout << "Base2::func1" << std::endl; }
virtual void func2() { std::cout << "Base2::func2" << std::endl; }
private:
int b2 = 1;
};
class Derive : public Base1, public Base2 {
public:
//子类重写func1
virtual void func1() { std::cout << "Derive::func1" << std::endl; }
//子类新增func3
virtual void func3() { std::cout << "Derive::func3" << std::endl; }
private:
int d1 =2;
};
int main()
{
Derive d;
return 0;
}
简单分析可知,虚函数多继承体系下派生类会根据声明顺序依次继承父类.继承方式类似于虚继承.
我们知道,单继承中,子类自己新增的虚函数会尾插到虚表的末尾.
那么多继承呢?是每个父类都添加?还是只添加到其中一个?添加到一个的话添加到哪里?
要知道结果,必须要看一眼虚表的真实情况.因此我们打印所有虚表看看情况.
int main()
{
Derive d;
/*打印d中Base1的虚表*/
std::cout<<"Base1的虚表"<<"\n";
PrintVFTable(*(VFPTR**)(&d));
puts("");
/*打印d中Base2的虚表*/
std::cout<<"Base2的虚表"<<"\n";
//方法1,手动计算指针偏移
//PrintVFTable((VFPTR*)*(VFPTR*)((char*)&d+sizeof(Base1)));
//PrintVFTable(*(VFPTR**)((char*)&d+sizeof(Base1)));
//方法2,切片,自动计算指针偏移 -- 推荐,不容易出错
Base2 *b2 = &d;
PrintVFTable(*(VFPTR**)b2);
return 0;
}
结果也证明,子类重写会对所有父类的同名函数进行覆盖
观察结果还发现,两个func1的地址居然不一样.这其实涉及到C++this指针的原理问题->this指针修正.
要搞明白是什么情况,我们需要观察汇编代码,去看更深层次的逻辑.
例程代码
int main(){
Derive d;
Base1 *ptr1 = &d;
Base2 *ptr2 = &d;
ptr1->func1();
ptr2->func1();
return 0;
}
先观察ptr1
再看ptr2
对比可以发现,ptr2要比ptr1走多了好几步才能正确调用fun1.
解释:
看ptr2的的中间过程有句汇编sub ecx,8,功能是ecx-8再放到ecx中.而ecx在类中通常表示类的this指针,即sub ecx,8得功能是将this指针-8,这里8刚好是sizeof(Base1)的值,因此sub ecx,8就可以解释成this向下偏移8个字节,因为对象的this指针位于低字节,这就同时刚好满足了this指向Base2.再结合问题场景,就可以同步证明ptr2多走的这几步目的就是为了让指针正确偏移回对象d的this.
再结合切片原理,切片后会自动计算将ptr2指向了d中Base2的首地址,可以推测切片后ecx也指向了Base2的首地址.为了能够发生多态,需要将ecx重新偏移至正确位置.
这就是多继承下多态的原理
所以，虚表中存放的地址大多数情况下就是虚函数的真实地址，但在某些特定的优化场景下，它可能指向一个中间函数，这个中间函数再负责跳转到真实的函数地址。这种间接调用的机制有时被称为“thunk”，它允许编译器在运行时进行更复杂的控制流分析和优化。
对于现代的C++编译器，如GCC或Clang，它们默认的行为是在虚表中直接存储虚函数的真实地址，除非有特殊的优化需求。如果想了解具体的实现，可以通过反汇编工具（如objdump, IDA Pro等）查看编译后的二进制文件，检查虚表的结构和内容。
菱形继承本来就是很复杂的东西,再加上多态,更加复杂,实际工作中也很少会使用菱形继承多态.
简单演示一下,有兴趣的读者可以自行扩展研究.
class A {
public:
virtual void func1() {}
public:
int _a;
};
class B : public A {
public:
virtual void func1() {}
public:
int _b;
};
class C : public A {
public:
virtual void func1() {}
public:
int _c;
};
class D : public B, public C {
public:
virtual void func1() {}
public:
int _d;
};
int main() {
D d;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
return 0;
}
内存布局:
class A {
public:
virtual void func1() {}
public:
int _a;
};
class B : virtual public A {
public:
virtual void func1() {}
//virtual void func2() {}
public:
int _b;
};
class C : virtual public A {
public:
virtual void func1() {}
//virtual void func3() {}
public:
int _c;
};
class D : public B, public C {
public:
virtual void func1() {}
public:
int _d;
};
(其中要求最远类必须重写虚基类A的虚函数,因为要消除二义性,是B是C都不好,最好是D.)
内存布局:
和非多态菱形虚拟继承很类似.只重写虚基类虚函数时,只有虚基类有虚表
class A {
public:
virtual void func1() {}
public:
int _a;
};
class B : virtual public A {
public:
virtual void func1() {}
virtual void func2() {}
public:
int _b;
};
class C : virtual public A {
public:
virtual void func1() {}
virtual void func3() {}
public:
int _c;
};
class D : public B, public C {
public:
virtual void func1() {}
public:
int _d;
};
内存布局:
64位环境下内存布局
推测虚基表中低四字节是存放虚表偏移量,也可能是到B或C类型首部的偏移量.
静态绑定又称为前期绑定(早绑定),在程序编译期间就确定了程序的行为,即编译时,也称为静态多态.
静态多态例子:函数重载,如std::cout<<的类型自动识别,原理就是函数名修饰规则将operator<<(不同的参数)在编译时生成多份(都是生成多份,C语言需要程序员手动,C++由编译器自动生成),使传的参数不同时能够对外表现出不同的行为.这种技术给开发者和用户都带来了使用上的便利.
动态绑定也称为后期绑定(晚绑定),是在程序运行期间,即运行时,根据具体拿到的类型确定程序的具体行为,调用具体的函数,也称为动态多态.虚函数多态就是动态多态.
inline如果被编译器识别成内联函数,则该函数是没有地址的. 与虚表中存放虚函数的地址有冲突.
但事实上,inline 和 virtual 可以一起使用 :
这取决于使用该函数的场景:内联是一个建议性关键字,如果发生多态,则编译器会忽略内联.如果没有发生多态,才有可能成为内联函数
即:多态和内联可以一起使用,但同时只能有一个发生
静态成员函数不能是虚函数,因为静态成员函数没有this指针,与多态发生条件矛盾
父类引用/指针去调用
static函数没有隐藏this参数.不满足虚函数重写条件"三同"
静态成员函数目的是给所有对象共享,不是为了实现多态
构造,拷贝构造不能是虚函数
赋值运算符重载也和拷贝构造一样,不建议写成虚函数,虽然编译器不报错.
一般来说,普通函数会比构成多态调用的虚函数快.但要注意,是虚函数在构成多态调用的情况下.
看例子1:
class AA {
public:
virtual void func1() {}
};
class BB : public AA {
void func2(){};
};
int main() {
AA a;
BB b;
a.func1();
b.func1();
return 0;
}
在VS2019-32位环境下,两种函数在对象的调用下汇编代码是一样的.因此这种情况下它们一样快.
看例子2:
成员函数为非虚函数时,指针调用是普通调用
class AA {
public:
void func1() {}
};
class BB : public AA {
};
int main()
{
BB b;
BB*ba = &b;
pb->func1();
return 0;
}
看例子3:
class AA {
public:
virtual void func1() {}
};
class BB : public AA {
};
int main()
{
AA*pa = &a;
pa->func1();
BB*pb = &b;
pa->func1();
return 0;
}
在虚函数情况下(包括继承和非继承),使用指针调用都会触发多态的调用方式,显然这时调用虚函数效率会比普通函数慢.
小结:
通过上面几个例子分析,发现有虚函数,且是指针的情况下,无论有没有发生多态,调用方式都会发生改变.上面举的名词"多态的调用方式"是为了描述这种调用方式.
这种调用方式简化了编译器的调用逻辑:只要是虚函数,且是指针/引用,都会去虚表中找.如果满足多态的条件就能发生多态的现象,否则就是正常调用.
因此,需要注意区分多态的调用方式与多态的现象.常说的多态的两个条件是指满足这两个条件才能触发多态的现象.与是否是多态的调用方式无关.
官方公众号