【C++】多态相关知识详细梳理
1.多态的概念
从理论体系来看，在计算机科学中多态性是一个复杂且重要的概念。具体而言，在系统运行过程中，同一类对象（如变量）可能通过不同的机制来执行相同的指令。这种特性使得程序能够更加灵活地适应不同的场景需求。
**** 例如：一个人去买票，成年人是全额，学生票是半价。
多态的概念倒是很简单。
2.如何构成多态
2.1多态的构成条件
多态是指在不同继承结构中的类型实例通过调用相同的函数表现出不同的功能。例如，在Person类的基础上发展出Student和 Military两个子类。其中，在购买机票时全价；而Student则享受半价优惠；军事人员则获得优先购票权。
首先多态是继承关系中发生的 ，此外还有两个条件：
在C++程序中, 若要调用该虚操作, 请确保使用实例变量以指针或引用的形式进行访问.
若被调用的功能体为非静态成员函数, 则该派生类必须实现其父类中定义的动态绑定操作.
2.2虚函数
**** 这里就不得不引出虚函数的概念了：
虚函数：即被virtual修饰的类成员函数称为虚函数。
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl;}
};2.3虚函数的重写
对派生体功能(覆盖)：在派生体中存在一个与基本类型中的功能完全一致的虚拟方法(即其子类继承了基类的功能)，这种现象被称为方法重写或功能覆盖。
class Person {
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
virtual void BuyTicket() { cout << "买票-半价" << endl; }
/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，
虽然也可以构成重写,但是该种写法不是很规范，不建议这样使用*/
/*void BuyTicket() { cout << "买票-半价" << endl; }*/
};
void Func(Person& p)
{ p.BuyTicket(); }
int main()
{
Person ps;
Student st;
Func(ps);
Func(st);
return 0;
}那重写后有什么用呢，定义虚函数是为了重写，重写是为了构成多态。
执行该代码行后会观察到以下现象：当Func函数接收Person对象时，默认会触发该对象继承自父类的某个基础功能模块；而当传递给st对象则会触发Student类特有的功能模块实现；这种基于不同参数类型自动选择对应功能的行为即所谓的重写后的成员方法；通过这种方法实现了面向不同实体类型的功能扩展机制；这就是多态编程思想的基础体现。
总结：当传递给基类指针的对象指向派生类时（是否是通过切片操作得到），则会调用该派生类的重写方法；否则仍会调用基类的方法。
此外，还需要提及虚函数重写中的两个例外：
1. 协变(基类与派生类虚函数返回值类型不同，其他相同)
在实现派生类与基类之间的关系时，在满足特定条件下（即当与基类虚函数的返回类型不同时），如果该情况下的派生类虚函数实现了对基数对象的访问（具体而言是返回其指针或引用），则这种现象被称为协变）。
例如：
class A{};
class B : public A {};
class Person {
public:
//virtual A& f() {return *(new A);}//派生类返回派生类的引用
virtual A* f() {return new A;}//基类返回基类的指针
};
class Student : public Person {
public:
//virtual B& f() {return *(new B);}//派生类返回派生类的引用
virtual B* f() {return new B;}//派生类返回派生类的指针
};2. 析构函数的重写（基于基类与派生类解析构造成员名的不同）
如果基类解析构造成员是纯虚数成员，则只要在派生类中定义解析构造成员（无论是否附加virtual关键字），都与其父代解析构造成员构成重写关系。尽管基类与派生解析构造成员名不一致，在表面看来似乎违背了解析构造成员重写的规则；但实际上，在编译过程中解析构造成员名会被特殊处理并被统一命名为destructor
例如：
class Person {
public:
virtual ~Person() {cout << "~Person()" << endl;}
};
class Student : public Person {
public:
virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函
// 数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
Person* p1 = new Person;
Person* p2 = new Student;//切片
delete p1;
delete p2;
return 0;
}在软件开发中，“加载操作”、“覆盖操作（重新编写）”以及“隐藏（重新定义）”的定义确实容易让人混淆。为了更清晰地理解这些概念的本质区别与适用场景，建议我们通过对比分析来深入探讨。
重载、覆盖(重写)、隐藏(重定义)的对比：
2.4 override 和 final 关键字（C++11）
由于C++对于函数重写的规范较为严格，在实际开发过程中可能会导致程序运行时出现错误；然而这些潜在问题在编译阶段并未提供相应的提示信息；因此，在C++11标准中新增了override和final这两个关键字用于检测函数重写情况。
class Car
{
public:
virtual void Drive() final {}
};
class Benz :public Car
{
public:
virtual void Drive() { cout << "Benz-舒适" << endl; }
//error C3248: "Car::Drive": 声明为 "final" 的函数不能由 "Benz::Drive" 重写
};2. cover: 进行检查以验证基类虚函数是否被继承类覆盖实现。若未被覆盖则会抛出错误信息。
class Car{
public:
virtual void Drive(){}
};
class Benz :public Car {
public:
virtual void Drive() override {cout << "Benz-舒适" << endl;}
//加在派生类虚函数，检查基类对应虚函数是否被重写
}3.抽象类
**概念：当将虚函数的返回值设为零时，则该函数被视为纯虚函数。拥有纯虚功能的类别被定义为抽象类型（亦称接口类型），这些抽象类型的实体本身无法直接生成实例。尽管继承自其他基底类型的一般派生类型也无法直接生成实例，在某些情况下仍需进行特殊处理以确保其可操作性与功能性需求相适应？然而，在某些情况下仍需进行特殊处理以确保其可操作性与功能性需求相适应？然而，在某些情况下仍需进行特殊处理以确保其可操作性与功能性需求相适应？然而，在某些情况下仍需进行特殊处理以确保其可操作性与功能性需求相适应？然而，在某些情况下仍需进行特殊处理以确保其可操作性与功能性需求相适应？不过这通常是不必要的限制因此在大多数编程语言中不允许对虚拟方法进行显式初始化操作尽管如此但在某些高级编程语言中可以通过显式初始化机制来实现这一功能这通常涉及对相关类型的进一步细化定义从而扩展了系统的灵活性与可维护性
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();
}接口继承和实现继承的概念：
普通成员函数的行为通过继承实现了功能传递；派生体实例能够调用基体成员的功能；纯虚成员的行为通过接口实现了功能定义；派生体实例能够调用其基体抽象成员的功能；**如果不希望该类型支持多态性，则不应将其成员定义为纯虚成员。
4.多态的原理
4.1虚函数表
首先用这段代码引出：
class Base
{
public:
virtual void Func1()
{
cout << "Func1()" << endl;
}
private:
int _b = 1;
};
int main()
{
Base b;
cout<<sizeof(b)<<endl;
return 0;
}通常情况下，在32位环境下，由于函数不在对象中占用空间，默认情况下对象的大小是4字节；但在实际操作中发现其真实大小却为8字节。
如果在vs中打开调试窗口，就会发现对象中多了一个变量__vfptr：
**在对象中这个特定的指针我们称作虚拟函数表指针（其中v代表虚拟关键字virtual），f则表示功能或功能相关的内容。**任何一个包含有虚拟功能的类都必然拥有一个对应的虚拟函数表指针；这是因为该类中的所有虚拟功能都需要将它们的功能地址存储到该虚拟功能列表中，并通过此列表来定位相应的操作方法或执行路径；因此，在编译过程中每当遇到需要调用这些方法时都会自动按照预先存储的信息进行相应的操作或数据处理等运算过程。
4.2虚表机制
再通过下面的代码更进一步探索虚表的机制：
// 针对上面的代码我们做出以下改造
// 1.我们增加一个派生类Derive去继承Base
// 2.Derive中重写Func1
// 3.Base再增加一个虚函数Func2和一个普通函数Func3
class Base
{
public:
virtual void Func1()
{
cout << "Base::Func1()" << endl;
}
virtual void Func2()
{
cout << "Base::Func2()" << endl;
}
void Func3()
{
cout << "Base::Func3()" << endl;
}
private:
int _b = 1;
};
class Derive : public Base
{
public:
virtual void Func1()
{
cout << "Derive::Func1()" << endl;
}
private:
int _d = 2;
};
int main()
{
Base b;
Derive d;
return 0;
}
通过观察与测试, 我们发现了几个问题:
1. d对象由两部分组成: 一部分来自父类继承的成员, 另一部分则是派生类自身独有的成员, 而虚表指针也包含在这两个部分之中。 2. 基类b与派生类d的对象在虚表上有显著差异, 在此我们承担了Func1的任务, 因此d对象中的虚表存储了从语法层面来说的Func1重写版本, 这也意味着对于虚拟函数而言, 重写即覆盖这一概念源于原理层对覆盖行为的理解. 3. Func2继承后成为虚拟函数并存入虚拟表中, 然而由于Func3不具备这一特性因而未被包含在虚拟表中. 4. 虚函数表本质上是一个用于存储虚拟函数指针的指针数组, 通常以null指针结束. **5. 总结而言: 派生类的虚拟表生成机制如下
a.先将基类中的虚表内容拷贝一份到派生类虚表中。
当派生类实现了基类中的一个纯虚拟函数时,现定义的同名成员函数作为基础实现该纯虚拟函数
c. 在继承关系中新增的虚拟成员按照它们在继承顺序中的排列排在其所属派生类基元表末尾。
特别注意其中虚表存储了用于指向虚拟方法实现的具体数据类型的指针而不是实际定义这些方法的行为类对象这种机制类似于普通的多态机制只不过在实现阶段通过引用间接访问这些方法以提高运行效率而不是在编译阶段生成大量动态链接库
4.3 动态绑定和静态绑定
1. 静态绑定又称为前期绑定(早绑定)，它在程序编译阶段决定了程序的行为，并被称为静态多态；例如：函数重载。
2. 动态绑定又称后期绑定(晚绑定)，它在程序运行阶段根据实际拿到的类型确定了具体的执行方式，并调用特定的函数；也称为动态多态。
5. 单继承和多继承关系的虚函数表
5.1 单继承中的虚函数表
首先看看这段代码：
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 :
virtual void func1() {cout<<"Derive::func1" <<endl;}
virtual void func3() {cout<<"Derive::func3" <<endl;}
virtual void func4() {cout<<"Derive::func4" <<endl;}
private :
int b;
};
当使用监视窗口观察时，并未显示func3和func4函数。由于编译器设计使得这两个特定的函数被隐式地隐藏在监视窗口中。无需担心这些细节；我们可以通过引用虚表机制来查看其内部功能。
ps：核心在于对象的头四个字节存的是虚表指针。
typedef void(*VFPTR) (); //定义函数指针变量
void PrintVTable(VFPTR vTable[])
{
// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
cout << " 虚表地址>" << vTable << endl;
for (int i = 0; vTable[i] != nullptr; ++i)
{
printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
VFPTR f = vTable[i];
f();
}
cout << endl;
}
int main()
{
Base b;
Derive d;
// 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数
// 指针的指针数组，这个数组最后面放了一个nullptr
// 1.先取b的地址，强转成一个int*的指针
// 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
// 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
// 4.虚表指针传递给PrintVTable进行打印虚表
// 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最
// 后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再
// 编译就好了。
VFPTR* vTableb = (VFPTR*)(*(int*)&b);
PrintVTable(vTableb);
VFPTR* vTabled = (VFPTR*)(*(int*)&d);
PrintVTable(vTabled);
return 0;
}
5.2 多继承中的虚函数表
先看一个多继承代码：
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;
};
typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
cout << " 虚表地址>" << vTable << endl;
for (int i = 0; vTable[i] != nullptr; ++i)
{
printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
VFPTR f = vTable[i];
f();
}
cout << endl;
}
int main()
{
Derive d;
VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
PrintVTable(vTableb1);
//由于Base1和Base2在被继承后是连续存放的，所以可以+sizeof(Base1)得到Base2部分的地址
VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d+sizeof(Base1)));
PrintVTable(vTableb2);
return 0;
}
根据上图可知：在多继承的情况下，未重写的虚拟函数被放置于第一个继承基类中的虚拟函数表内。这样做会导致该类中新增了两个虚拟指针地址。
6.总结
1.多态是由虚表来实现的。
2. 虚函数重写是基于父类拷贝到虚拟表中对应函数地址来完成的。时会使用父类接口和子类方法进行调用。
在继承关系中，在继承关系中，在继承关系中，在继承关系中，在继承关系中，在继承关系中，在继承关系中，在继承关系中，在继承关系中，在继承关系中，在继承关系中的基址与其实现体并非一致；并且一个派生类可能拥有多个虚拟基址；如实现多态时的情况
4.虚表地址存在对象的头四个字节处(32位)。
5.重载，重写以及重定义容易混淆，需要理清。
6.多态是在运行时确定的，属于动态绑定。
需在抽象类中定义纯虚函数以实现其功能（若无需重写，则无需定义纯虚函数）
避免设计过于复杂的菱形继承或虚拟菱形继承方案。由于其过于复杂导致容易出现错误且难以进行深入分析的同时该方案的性能表现略逊色于其他更为简洁的设计方案。
9.当一个子类中存在若干个父类具有纯 virtual 函数时，则该子类将对应生成相应的 virtual 表数量，并不会有额外的空置 virtual 表出现。
在多继承的情形下，在第一个继承的父类中将会有这些子类自行定义且未被重写的虚函数被存储于其对应的虚拟表中。