快乐的流畅：个人主页
个人专栏：《C语言》《数据结构世界》《进击的C++》
远方有一堆篝火，在为久候之人燃烧！
文章目录
一、虚函数与重写1.1 虚函数1.2 虚函数的重写1.3 重写的特例1.4 final和override（C++11）1.5 重载、重写(覆盖)、重定义(隐藏)的对比
二、多态的概念及定义2.1 多态的概念2.2 多态的定义
三、抽象类3.1 纯虚函数3.2 抽象类的概念3.3 接口继承与实现继承
四、多态的原理4.1 虚函数表4.2 虚函数表的打印4.3 单继承下的虚函数表4.3.1 一对一4.3.2 多对一4.3.3 一对多
4.4 多继承下的虚函数表4.5 多态的原理4.6 静态绑定与动态绑定4.7 菱形虚拟继承下的虚函数表
一、虚函数与重写
1.1 虚函数
虚函数：即被virtual修饰的类成员函数称为虚函数。
class Person
{
public:
virtual void BuyTicket() { cout << "买票-全价" << endl;}
};
1.2 虚函数的重写
虚函数的重写，又称覆盖。派生类有一个函数名、参数、返回值与基类虚函数相同的虚函数，则称派生类的虚函数重写了基类的虚函数。
class Person
{
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person
{
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
}
同时，虚函数重写，其意义在于继承函数接口，重写函数定义。
1.3 重写的特例
派生类要重写的虚函数，可以不用加virtual关键字（不推荐使用）
class Person
{
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person
{
public:
void BuyTicket() { cout << "买票-半价" << endl; }
}
原因：由于继承，派生类的同名函数继承了基类虚函数的特性。
协变 派生类和基类虚函数返回值类型不同，即基类虚函数返回基类对象的指针或引用，派生类返回派生类对象的指针或引用。
class A{};
class B : public A {};
class Person
{
public:
virtual A* f() {return new A;}
};
class Student : public Person
{
public:
virtual B* f() {return new B;}
};
析构函数的重写 如果基类的析构函数为虚函数，那么只要派生类的析构函数定义，便构成重写。
class Person
{
public:
virtual ~Person() {cout << "~Person()" << endl;}
};
class Student : public Person
{
public:
virtual ~Student() { cout << "~Student()" << endl; }
};
原因：编译器此时做了特殊处理，将基类和派生类的析构函数名，都改为destructor，因此构成重写。
那么为什么要这么处理呢？请看下面代码：
int main()
{
Person* p1 = new Person;
Person* p2 = new Student;
delete p1;
delete p2;
return 0;
}
原因：只有这样处理，构成多态，才能正确调用各自的析构函数。
1.4 final和override（C++11）
final：可以修饰变量、函数和类。 对于变量，确保初始化后不能被修改 对于函数，确保不能被子类重写 对于类，确保不能被继承
class Car
{
public:
virtual void Drive() final {}
};
class Benz :public Car
{
public:
virtual void Drive() {cout << "Benz-舒适" << endl;}
};
加上final，以上代码会编译报错。
override：检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
class Car
{
public:
virtual void Drive() {}
};
class Benz :public Car
{
public:
virtual void Drive() override { cout << "Benz-舒适" << endl; }
};
1.5 重载、重写(覆盖)、重定义(隐藏)的对比
二、多态的概念及定义
2.1 多态的概念
多态，顾名思义，即多种形态。具体来说，就是不同对象执行同一行为而产生不同的结果。
比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。
2.2 多态的定义
多态，是在不同继承关系的类对象，去调用同一函数，产生不同的行为。
比如：Student继承了Person。Person对象买票全价，Student对象买票半价。
构成多态需要两个条件：
通过父类的指针或引用调用被调用的必须是虚函数，并且虚函数必须重写
三、抽象类
3.1 纯虚函数
在虚函数的后面写上 =0 ，则这个函数为纯虚函数。
class Car
{
public:
virtual void Drive() = 0;
};
3.2 抽象类的概念
包含纯虚函数的类叫做抽象类，也叫接口类。
抽象类不能实例化出对象，派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。
class Car
{
public:
virtual void Drive() = 0;
};
class Benz :public Car
{
public:
virtual void Drive()
{
cout << "Benz-舒适" << endl;
}
};
class BMW :public Car
{
public:
virtual void Drive()
{
cout << "BMW-操控" << endl;
}
};
void Test()
{
Car* pBenz = new Benz;
pBenz->Drive();
Car* pBMW = new BMW;
pBMW->Drive();
}
意义：纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。
3.3 接口继承与实现继承
普通函数的继承，是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。
虚函数的继承，是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。
综上所述，虚函数就是为多态而生的，如果不实现多态，不要把函数定义成虚函数。
四、多态的原理
4.1 虚函数表
先来看一道题：32位平台下，sizeof(Base)是多少？
class Base
{
public:
virtual void Func1()
{
cout << "Func1()" << endl;
}
private:
int _b = 1;
};
正确答案是8byte！是不是很诧异？
其实，Base类里面还有一个隐藏的指针，称为虚函数表指针（简称虚表指针）。
经过观察发现，其类型为void**，并且(与平台有关，vs平台下)位于对象的最上方。
而且，这个指针指向了一张表，称为虚函数表（简称虚表）。虚函数表，是一个函数指针数组，里面存储了该类中虚函数的指针。
4.2 虚函数表的打印
由于监视窗口会隐藏一些真实的信息，并且观察起来不太直观和方便，所以我们写一个函数专门打印虚函数表，以便观察和检验。
typedef void(*VFT_PTR)();
void PrintVFTable(VFT_PTR* table)
{
for (int i = 0; table[i] != nullptr; ++i)
{
printf("[%d]: %p-> ", i, table[i]);
VFT_PTR f = table[i];
f();
}
cout << endl;
}
细节：
由于函数指针不太直观，先typedef重命名一下传参传入二级指针，也就是虚表指针这里利用一个性质：虚函数表以nullptr结尾，以作标识（vs平台）
至于如何取出虚表指针，这也是需要一定的技巧。先给出下面分析要用的main函数
int main()
{
Base b;
Derive d;
PrintVFTable(*(VFT_PTR**)&b);
PrintVFTable(*(VFT_PTR**)&d);
return 0;
}
细节：
利用性质：虚表指针在对象的开头（vs平台）取出对象地址，再强转为VFT_PTR**，这样解引用就可以直接获取虚表指针大小的内容
需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再编译就好了。
4.3 单继承下的虚函数表
4.3.1 一对一
class Base
{
public:
virtual void Func1()
{
cout << "Base::Func1()" << endl;
}
private:
int _b = 1;
};
class Derive : public Base
{
public:
virtual void Func1()
{
cout << "Derive::Func1()" << endl;
}
private:
int _d = 2;
};
运行结果：
4.3.2 多对一
class Base
{
public:
virtual void Func1()
{
cout << "Base::Func1()" << endl;
}
virtual void Func2()
{
cout << "Base::Func2()" << endl;
}
private:
int _b = 1;
};
class Derive : public Base
{
public:
virtual void Func1()
{
cout << "Derive::Func1()" << endl;
}
private:
int _d = 2;
};
运行结果：
4.3.3 一对多
class Base
{
public:
virtual void Func1()
{
cout << "Base::Func1()" << endl;
}
private:
int _b = 1;
};
class Derive : public Base
{
public:
virtual void Func1()
{
cout << "Derive::Func1()" << endl;
}
virtual void Func4()
{
cout << "Derive::Func4()" << endl;
}
private:
int _d = 2;
};
运行结果：
综上三种情况：
基类的虚函数表，（按照声明顺序）存储基类中的虚函数指针。派生类的虚函数表，先将基类的虚函数表拷贝过来，再对被重写的虚函数覆盖为派生类的虚函数，最后在末尾加上派生类新增的虚函数。
这里也体现了为什么重写又称覆盖，重写是语法层的叫法，覆盖是原理层的叫法。
4.4 多继承下的虚函数表
那么，有了上面单继承下的虚函数表的基础，我们再来看看多继承虚函数表有哪些变化吧。
class Base1
{
public:
virtual void func1()
{
cout << "Base1:func1()" << endl;
}
virtual void func2()
{
cout << "Base1:func2()" << endl;
}
private:
int _b1;
};
class Base2
{
public:
virtual void func1()
{
cout << "Base2:func1()" << endl;
}
virtual void func2()
{
cout << "Base2:func2()" << endl;
}
private:
int _b2;
};
class Derive :public Base1, public Base2
{
public:
virtual void func1()
{
cout << "Derive::func1()" << endl;
}
virtual void func3()
{
cout << "Derive::func3()" << endl;
}
private:
int _d1;
};
我们先来看看监视窗口：
我们可以发现，多继承下的派生类对象，将两个基类的虚表都继承了过来，所以后续打印时要注意打印两份虚表。
这里需要找到派生类对象中两个虚表指针的位置，可以用到切片的技巧，实现指针自动定位。
int main()
{
Base1 b1;
Base2 b2;
Derive d;
Base1* p1 = &d;
Base2* p2 = &d;
PrintVFTable(*(VFT_PTR**)&b1);
PrintVFTable(*(VFT_PTR**)&b2);
PrintVFTable(*(VFT_PTR**)p1);
PrintVFTable(*(VFT_PTR**)p2);
return 0;
}
运行结果：
结论：
派生类分别将各个基类的虚表拷贝过来，再对被重写的虚函数进行覆盖。唯一不同的，是派生类新增的虚函数，是放在第一个继承的基类部分虚表的最后。
4.5 多态的原理
讲了这么多虚函数表的内容，所以这跟多态的原理有什么关系呢？我们再来回看一开始这张多态调用分析图：
为什么要使用父类的指针或引用来调用？因为子类的虚表存储在继承的父类部分，这样才能统一调用父类子类各自的虚表。 为什么被调用的虚函数必须重写？因为这是一种接口继承，也是你要实现多态的根本目的。在重写了虚函数的实现后，调用时在父类子类各自的虚表查找各自不同实现的虚函数，才能构成多态。
4.6 静态绑定与动态绑定
静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载。动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
所以，满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。
4.7 菱形虚拟继承下的虚函数表
这里已经属于考试不考，实际中不常用的范围了，有兴趣可以看看~
class A
{
public:
virtual void func1()
{}
int _a;
};
class B :virtual public A
{
public:
virtual void func1()
{}
virtual void func2()
{}
int _b;
};
class C :virtual public A
{
public:
virtual void func1()
{}
virtual void func3()
{}
int _c;
};
class D :public B, public C
{
public:
virtual void func1()
{}
virtual void func4()
{}
int _d;
};
int main()
{
D d;
d._b = 1;
d._c = 2;
d._d = 3;
d._a = 4;
return 0;
}
虚表（虚函数表）：存储虚函数地址
虚基表：存储偏移量
细节：
D类中必须重写func1，避免B和C类多重继承时重写的歧义性虚拟继承中，重写的func1位于A部分虚表，而B和C类中未重写的虚函数，分别位于B和C部分的虚表D类中新增的虚函数，放在第一个继承类部分的虚表（即B部分虚表）虚基表中（总共两个位置），第一位置记录距离虚表指针的偏移量，第二位置记录距离A部分的偏移量
实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。
真诚点赞，手有余香
推荐文章
发表评论