C++ 多态
前言
本文将会向你介绍多态的概念，重写，虚表，纯虚函数等知识点
多态的概念
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。
那么在继承中要构成多态还有两个条件：
- 必须通过基类的指针或者引用调用虚函数
- 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写（重写的概念会在下文介绍）
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字节，并不是我们想的（int（4字节）+ char（1字节）+3字节（内存对齐）= 8字节 ）
原因是当存在虚函数的时候，每个对象都会有一个虚函数表指针（vfptr），该指针指向一个虚函数表（vtable）。虚函数表是一个存储了虚函数地址的数组，每个虚函数在表中占据一个位置。通过虚函数表指针，程序可以在运行时动态地确定调用哪个虚函数。
对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代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;
}
若是我们屏蔽了派生类对纯虚函数的重写，则无法构建对象
小结
今日的分享就到这里啦，如果本文存在疏漏或错误的地方还请您能够指出！