目录
一. 多态的概念
1.静态多态（编译时多态）
二.动态多态的定义及实现
1.多态的构成条件
2.虚函数
3.虚函数的重写/覆盖
4.虚函数重写的一些其他问题
1）.协变
2）.析构函数的重写
5.override 和 final关键字
1）.override 关键字
2）.final 关键字
6.重载/重写/隐藏的对比
三. 纯虚函数和抽象类
四. 多态的原理
1.虚函数表指针
2 多态的原理
1）.多态是如何实现的
2）.动态绑定与静态绑定
3）.虚函数表
一. 多态的概念
多态(polymorphism)的概念：通俗来说，就是多种形态。多态分为编译时多态(静态多态)和运行时多态(动态多态)，这里我们重点讲运行时多态，编译时多态(静态多态)和运行时多态(动态多态)。编译时多态(静态多态)主要就是前面的函数重载和函数模板，他们传不同类型的参数就可以调用不同的函数，通过参数不同达到多种形态，之所以叫编译时多态，是因为他们实参传给形参的参数匹配是在编译时完成的，我们把编译时一般归为静态，运行时归为动态。运行时多态，具体点就是去完成某个行为(函数)，可以传不同的对象就会完成不同的行为，就达到多种形态。
1.静态多态（编译时多态）
// 函数重载
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }
// 模板
template <typename T>
T max(T a, T b) { return a > b ? a : b; } 二.动态多态的定义及实现
1.多态的构成条件
多态是⼀个继承关系下的类对象，去调用同⼀函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象优惠买票。
- 必须指针或者引用调用虚函数
- 被调用的函数必须是虚函数
说明：要实现多态效果，第一必须是基类的指针或引用，因为只有基类的指针或引用才能既指向派生类对象；第二派生类必须对基类的虚函数重写/覆盖，重写或者覆盖了，派生类才能有不同的函数，多态的不同形态效果才能达到。
2.虚函数
类成员函数前面加virtual修饰，那么这个成员函数被称为虚函数。注意非成员函数不能加virtual修饰。
class Person
{
public:
virtual void BuyTicket() { cout << "买票-全价" << endl;}
}3.虚函数的重写/覆盖
虚函数的重写/覆盖：派生类中有⼀个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称派生类的虚函数重写了基类的虚函数。
注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性)，但是该种写法不是很规范，不建议这样使用，不过在考试选择题中，经常会故意买这个坑，让你判断是否构成多态。
class Person
{
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
void BuyTicket() { cout << "买票-打折" << endl; }
};
void Func(Person& ptr)
{
// 这里可以看到虽然都是Person指针Ptr在调用BuyTicket
// 但是跟ptr没关系，而是由ptr指向的对象决定的。
ptr.BuyTicket();
}
int main()
{
Person ps;
Student st;
Func(ps);
Func(st);
return 0;
}小试牛刀
以下程序输出结果是什么（）
A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确
答案：B. B->1 。重写的本质是：重写虚函数的实现，不重写参数。
4.虚函数重写的一些其他问题
1）.协变
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。协变的实际意义并不大，所以我们了解⼀下即可。
协变
class A {};
class B : public A {};
class Person {
public:
virtual A* BuyTicket()
{
cout << "买票-全价" << endl;
return nullptr;
}
};
class Student : public Person {
public:
virtual B* BuyTicket()
{
cout << "买票-打折" << endl;
return nullptr;
}
};
void Func(Person* ptr)
{
ptr->BuyTicket();
}
int main()
{
Person ps;
Student st;
Func(&ps);
Func(&st);
return 0;
}2）.析构函数的重写
基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor，所以基类的析构函数加了vialtual修饰，派生类的析构函数就构成重写。
class A
{
public:
virtual ~A()
{
cout << "~A()" << endl;
}
};
class B : public A {
public:
// 构成重写
~B()
{
cout << "~B()->delete:" << _p << endl;
delete _p;
}
protected:
int* _p = new int[10];
};
// 只有派⽣类Student的析构函数重写了Person的析构函数，下⾯的delete对象调⽤析构函数，才能
// 构成多态，才能保证p1和p2指向的对象正确的调⽤析构函数
int main()
{
A* p1 = new A;
A* p2 = new B;
// p1->destructor() + operator delete
delete p1;
delete p2;
return 0;
}我们可以看到，如果~A()，不加virtual，那么delete p2时只调用的A的析构函数，没有调用B的析构函数，就会导致内存泄漏问题，因为~B()中在释放资源。
注意：这个问题面试中经常考察，一定要结合类似的样例才能讲清楚，为什么基类中的析构函数建议设计为虚函数
5.override 和 final关键字
从上面可以看出，C++对虚函数重写的要求比较严格，但是有些情况下由于疏忽，比如函数名写错参数写错等导致无法构成重写，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此C++11提供了override，可以帮助用户检测是否重写。如果我们不想让派生类重写这个虚函数，那么可以用final去修饰。
1）.override 关键字
- 显式标记重写：明确指示派生类中的函数是覆盖基类的虚函数，提高代码可读性
- 编译时检查：强制编译器验证函数签名是否与基类虚函数完全匹配（函数名、参数、常量性、引用限定符等）。若签名不匹配（如参数类型错误、拼写错误），直接报错
// error C3668: “Benz::drive”: 包含重写说明符“override”的⽅法没有重写任何基类⽅法
class Car {
public:
virtual void Dirve()
{}
};
class Benz :public Car {
public:
virtual void drive() override
{ cout << "Benz-舒适" << endl; }
};
int main()
{
return 0;
}2）.final 关键字
- 禁止类继承：标记类为
final后，任何尝试继承的行为会触发编译错误 - 禁止虚函数重写：标记虚函数为
final后，派生类无法覆盖该函数
// error C3248: “Car::Drive”: 声明为“final”的函数⽆法被“Benz::Drive”重写
class Car
{
public :
virtual void Drive() final {}
};
class Benz :public Car
{
public :
virtual void Drive() { cout << "Benz-舒适" << endl; }
};
int main()
{
return 0;
}6.重载/重写/隐藏的对比
| 类型 | 要求 | 作用域 |
|---|---|---|
| 重写 | 虚函数 + 三同 | 继承关系 |
| 重载 | 同名函数 + 不同参数列表 | 同一类 |
| 隐藏 | 非虚函数同名（派生类覆盖基类） | 继承关系 |
三. 纯虚函数和抽象类
在虚函数的后面写上 = 0 ，则这个函数为纯虚函数，纯虚函数不需要定义实现(实现没啥意义因为要被派生类重写，但是语法上可以实现)，只要声明即可。包含纯虚函数的类叫做抽象类，抽象类不能实例化出对象，如果派生类继承后不重写纯虚函数，那么派生类也是抽象类。纯虚函数某种程度上强制了派生类重写虚函数，因为不重写实例化不出对象。
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;
}
};
int main()
{
// 编译报错：error C2259: “Car”: ⽆法实例化抽象类
//Car car;
Car* pBenz = new Benz;
pBenz->Drive();
Car* pBMW = new BMW;
pBMW->Drive();
return 0;
}四. 多态的原理
1.虚函数表指针
小试牛刀
下面编译为32位程序的运行结果是什么（）
A. 编译报错 B. 运行报错 C. 8 D. 12
class Base
{
public :
virtual void Func1()
{
cout << "Func1()" << endl;
}
protected:
int _b = 1;
char _ch = 'x';
};
int main()
{
Base b;
cout << sizeof(b) << endl;
return 0;
}答案：D.12。注意是32位
上面题目运行结果12bytes，除了_b和_ch成员，还多一个_vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为一个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称虚表。
2 多态的原理
我们将使用下面这个代码讲解。
class Person
{
public:
virtual void BuyTicket() { cout << "买票-全价" << endl; };
protected:
string _name;
};
class Student :public Person
{
public:
virtual void BuyTicket() { cout << "买票-打折" << endl; };
protected:
int _id;
};
class Soldier : public Person {
public:
virtual void BuyTicket() { cout << "买票-优先" << endl; };
protected:
string _codename; // 代号
};
void Func(Person* ptr)
{
// 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket
// 但是跟ptr没关系，⽽是由ptr指向的对象决定的。
ptr->BuyTicket();
}
int main()
{
// 其次多态不仅仅发⽣在派⽣类对象之间，多个派⽣类继承基类，重写虚函数后
// 多态也会发⽣在多个派⽣类之间。
Person ps;
Student st;
Soldier sr;
Func(&ps);
Func(&st);
Func(&sr);
return 0;
}1）.多态是如何实现的
从底层的角度Func函数中ptr->BuyTicket()，是如何作为ptr指向Person对象调用Person::BuyTicket， ptr指向Student对象调用Student::BuyTicket的呢？通过下图我们可以看到，满足多态条件后，底层不再是编译时通过调用对象确定函数的地址，而是运行时到指向的对象的虚表中确定对应的虚函数的地址，这样就实现了指针或引用指向基类就调用基类的虚函数，指向派生类就调用派生类对应的虚函数。第一张图，ptr指向的Person对象，调用的是Person的虚函数；第二张图，ptr指向的Student对象，调用的是Student的虚函数。
2）.动态绑定与静态绑定
对不满足多态条件(指针或者引用+调用虚函数)的函数调用是在编译时绑定，也就是编译时确定调用函数的地址，叫做静态绑定。
满足多态条件的函数调用是在运行时绑定，也就是在运行时到指向对象的虚函数表中找到调用函数的地址，也就做动态绑定
3）.虚函数表
- 基类对象的虚函数表中存放基类所有虚函数的地址。
- 派生类由两部分构成，继承下来的基类和自己的成员，一般情况下，继承下来的基类中有虚函数表指针，自己就不会再生成虚函数表指针。但是要注意的这里继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同一个，就像基类对象的成员和派生类对象中的基类对象成员也独立的。
- 派生类中重写的基类的虚函数，派生类的虚函数表中对应的虚函数就会被覆盖成派生类重写的虚函数地址
- 派生类的虚函数表中包含，基类的虚函数地址，派⽣类重写的虚函数地址，派⽣类自己的虚函数地址三个部分。
- 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个0x00000000标记。(这个C++并没有进行规定，各个编译器自行定义的，vs系列编译器会再后面放个0x00000000标记，g++系列编译不会放)
- 虚函数存在哪的？虚函数和普通函数一样的，编译好后是一段指令，都是存在代码段的，只是虚函数的地址又存到了虚表中
- 虚函数表存在哪的？这个问题严格说并没有标准答案C++标准并没有规定，我们写下面的代码可以对比验证一下。vs下是存在代码段(常量区)
class Base {
public:
virtual void func1() { cout << "Base::func1" << endl; }
virtual void func2() { cout << "Base::func2" << endl; }
void func5() { cout << "Base::func5" << endl; }
protected:
int a = 1;
};
class Derive : public Base
{
public:
// 重写基类的func1
virtual void func1() { cout << "Derive::func1" << endl; }
virtual void func3() { cout << "Derive::func1" << endl; }
void func4() { cout << "Derive::func4" << endl; }
protected:
int b = 2;
};
int main()
{
Base b1;
Base b2;
Derive d;
return 0;
}
这里Derive中没有看到func3函数，这个vs监视窗口看不到，可以通过内存窗口查看
| 性 | 说明 |
|---|---|
| 绑定时机 | 运行时动态绑定 |
| 内存开销 | 每个对象增加一个_vptr，每个类一个虚表 |
| 继承行为 | 派生类继承并可能覆盖基类虚表条目 |
| 多继承处理 | 为每个基类维护独立虚表 |
| 性能影响 | 间接调用带来轻微开销，现代编译器可优化 |
//使用上面的代码
int main()
{
int i = 0;
static int j = 1;
int* p1 = new int;
const char* p2 = "xxxxxxxx";
printf("栈:%p\n", &i);
printf("静态区:%p\n", &j);
printf("堆:%p\n", p1);
printf("常量区:%p\n", p2);
Base b;
Derive d;
Base* p3 = &b;
Derive* p4 = &d;
printf("Person虚表地址:%p\n", *(int*)p3);
printf("Student虚表地址:%p\n", *(int*)p4);
printf("虚函数地址:%p\n", &Base::func1);
printf("普通函数地址:%p\n", &Base::func5);
return 0;
}
