当前位置：首页 > news >正文

第十一讲 | 多态

news 来源：原创 2025/6/3 22:26:27

多态

一、多态的概念
二、多态的定义及实现
- 1、动态多态的构成条件
- - （1）、实现多态还有两个必须重要条件
  - （2）、虚函数
  - （3）、虚函数的重写/覆盖
  - （4）、多态场景的一个选择题
  - （5）、虚函数重写的一些其他问题
  - - 协变(了解)。也构成重写，进而构成多态。
    - 析构函数的重写
  - （6）、override 和 final 关键字
  - （7）、重载/重写/隐藏的对比
三、纯虚函数和抽象类
四、多态的原理
- 1、虚函数表指针
- 2、多态的原理
- - （1）、多态是如何实现的
  - （2）、动态绑定与静态绑定
  - （3）、虚函数表

一、多态的概念

多态(polymorphism)的概念：通俗来说，就是多种形态，多态更多指的是函数的行为。多态分为编译时多态(静态多态)和运行时多态(动态多态)，这里我们重点讲运行时多态。编译时多态(静态多态)主要就是我们前面讲的函数重载和函数模板，他们传不同类型的参数就可以调用不同的函数，通过参数不同达到多种形态。之所以叫编译时多态，是因为他们实参传给形参的参数匹配是在编译时完成的。我们把编译时一般归为静态，运行时归为动态。

运行时多态，看起来调用的是同一个函数，具体点就是去完成某个行为(函数)，可以传不同的对象就会完成不同的行为，可以理解为传递不同的对象，根据不同的对象去调用对应的不同的函数，就达到多种形态。比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是优惠买票(5折或75折)；军人买票时是优先买票。再比如，同样是动物叫的一个行为(函数)，传猫对象过去，就是(>^ω^<)喵，传狗对象过去，就是"汪汪"。

二、多态的定义及实现

1、动态多态的构成条件

动态多态是一个继承关系下的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象优惠买票。

（1）、实现多态还有两个必须重要条件

1、必须是基类的指针/引用调用虚函数（基类的指针/引用指向哪个类对象就调用哪个类对应的虚函数）

2、被调用的函数必须是虚函数，并且完成了虚函数重写/覆盖。

说明：要实现多态效果，第一必须是基类的指针或引用，因为只有基类的指针或引用才能既指向基类对象又指向派生类对象；第二派生类必须对基类的虚函数完成重写/覆盖，重写或者覆盖了，基类和派生类之间才能有不同的函数，多种形态效果才能达到。

在这里插入图片描述

（2）、虚函数

类成员函数前面加virtual修饰，那么这个成员函数被称为虚函数。注意非成员函数不能加virtual修饰，会报错。（注意与前面虚继承的virtual所表达的含义不一样）

class Person
{
public:virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

（3）、虚函数的重写/覆盖

虚函数的重写/覆盖：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同。注意参数列表只看形参类型是否相同即可，形参参数名和缺省值不一样是可以的。提一句，构成函数重载也是看形参类型不同。)，称派生类的虚函数重写了基类的虚函数。

注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性)，但是该种写法不是很规范，不建议这样使用，不过在考试选择题中，是构成多态的，经常会故意埋这个坑，让你判断是否构成多态。（注意：基类类成员函数不加virtual，派生类类成员函数加virtual，不是重写，不构成多态）

按照之前多学，看起来调用的都是同一个函数Person里的BuyTicket()，但是这里很明显不是，传递不同类型的对象就可以调用不同的函数。赋值兼容转换，父类的指针/引用可以指向父/派生类对象。

// 指针——实现多态
class Person 
{
public:virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person 
{
public:virtual 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;
}

// 引用也可以——实现多态
void Func(Person& ptr)
{ptr.BuyTicket();
}
int main()
{Person ps;Student st;Func(ps);Func(st);return 0;
}

在这里插入图片描述

实现多态必须严格同时遵守两个必须重要条件！若其中一个条件满足不了必不能实现动态多态。

若不是基类的指针/引用调用虚函数：

// 传值也可以——基类的拷贝构造，但是不能实现多态。
void Func(Person ptr)
{ptr.BuyTicket();
}
int main()
{Person ps;Student st;Func(ps);Func(st);return 0;
}

在这里插入图片描述

若被调用的函数不是虚函数：

class Person 
{
public:void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person 
{
public:void BuyTicket() { cout << "买票-打折" << endl; }
};
void Func(Person& ptr)
{ptr.BuyTicket();
}
int main()
{Person ps;Student st;Func(ps);Func(st);return 0;
}

在这里插入图片描述

重写基类虚函数时，派生类的虚函数不加virtual也构成重写，达到多态的效果。

class Person 
{
public:virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person 
{
public:void BuyTicket() { cout << "买票-打折" << endl; }
};
void Func(Person& ptr)
{ptr.BuyTicket();
}
int main()
{Person ps;Student st;Func(ps); Func(st);return 0;
}

在这里插入图片描述

多态的应用场景不仅仅是在基类和派生类之间，还可以是在派生类和派生类之间：

class Animal
{
public:virtual void talk() const{}
};
class Dog : public Animal
{
public:virtual void talk() const{std::cout << "汪汪" << std::endl;}
};
class Cat : public Animal
{
public:virtual void talk() const{std::cout << "(>^ω^<)喵" << std::endl;}
};
void letsHear(const Animal& animal)
{animal.talk();
}
int main()
{Cat cat;Dog dog;letsHear(cat);letsHear(dog);return 0;
}

在这里插入图片描述

（4）、多态场景的一个选择题

以下程序输出结果是什么（）
A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

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;
}

在这里插入图片描述

子类的指针p调用父类的test()，在test函数里调用func函数，这个func是this指针调用的，this->func();，那么this是A类型的指针还是B类型的指针呢？若是A类型的指针，那么就构成多态。

在这里插入图片描述

怎么看this是A类指针还是B类指针呢？
子类的指针p调用的是继承在派生类中的test吗？那这样看this指针类型就是B*？其实都不是的，注意继承不是把父类成员拷贝到派生类对象中。结合前面学习的隐藏，继承了一个成员函数，继承能用这个成员函数的原因是会先到派生类中搜索，派生类中找到了就不会到基类中搜索，派生类中没找到再到基类中搜索，编译的过程中找到对应的函数。当然重写不在隐藏的范围之内。综上，指针p调用test是编译时先去派生类中找，没找到再去基类中找（还是没找到会报错），所以派生类调用基类的函数的this指针类型是A*，this->func();是一个多态调用。指向谁调用谁，调用的是this指向的派生类对象对应的func虚函数。那是不是选D呀？注意重写是重新写函数的实现的部分，只有在多态调用下，基类成员函数加virtual但是派生类成员函数不加virtual的原因，派生类重写的虚函数是由基类虚函数的接口声明和派生类虚函数的实现(定义)构成，所以这个派生类中的函数不加virtual也是虚函数。

在这里插入图片描述

只有在多态调用下才会用基类的函数声明和派生类的函数实现。若不是在多态调用下：

在这里插入图片描述

（5）、虚函数重写的一些其他问题

协变(了解)。也构成重写，进而构成多态。

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。协变的实际意义并不大，所以我们了解一下即可。

class Animal
{
public:virtual Animal* talk() const{return nullptr;}
};
class Dog : public Animal
{
public:virtual Dog* talk() const{std::cout << "汪汪" << std::endl;return nullptr;}
};
class Cat : public Animal
{
public:virtual Cat* talk() const{std::cout << "(>^ω^<)喵" << std::endl;return nullptr;}
};
void letsHear(const Animal& animal)
{animal.talk();
}
int main()
{Cat cat;Dog dog;letsHear(cat);letsHear(dog);return 0;
}

在这里插入图片描述

协变返回类型也可以不是自己所在类的类型，此时还是构成多态：

class A
{};
class B : public A
{};
class Animal
{
public:virtual A* talk() const{return nullptr;}
};
class Dog : public Animal
{
public:virtual B* talk() const{std::cout << "汪汪" << std::endl;return nullptr;}
};
class Cat : public Animal
{
public:virtual B* talk() const{std::cout << "(>^ω^<)喵" << std::endl;return nullptr;}
};
void letsHear(const Animal& animal)
{animal.talk();
}
int main()
{Cat cat;Dog dog;letsHear(cat);letsHear(dog);return 0;
}

在这里插入图片描述

析构函数的重写

基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写。虽然基类与派生类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor，所以基类的析构函数加了virtual修饰，派生类的析构函数就构成重写。

下面的代码我们可以看到，如果~A()不加virtual，那么delete p2时只调用的A的析构函数，没有调用B的析构函数，B对象里的资源没有清理，就会导致内存泄漏问题，因为~B()中在释放资源。

注意：这个问题面试中经常考察，大家一定要结合类似下面的样例才能讲清楚，为什么基类中的析构函数建议设计为虚函数。

// 没问题：
class A
{
public:~A(){cout << "~A()" << endl;}
};
class B : public A {
public:~B(){cout << "~B()->delete:" << _p << endl;delete _p;}
protected:int* _p = new int[10];
};int main()
{A a1;B b1;return 0;
}

在这里插入图片描述

// 内存泄漏：
class A
{
public:~A(){cout << "~A()" << endl;}
};
class B : public A {
public:~B(){cout << "~B()->delete:" << _p << endl;delete _p;}
protected:int* _p = new int[10];
};
int main()
{A* p1 = new A;// new了一个A类对象，用A*类型的指针指着A* p2 = new B;// new了一个B类对象，用A*类型的指针指着// 没有构成多态，指针调用对应的函数是按照类型调用的，所以调用的都是A类的析构函数：// p1->~A() + operator delete(p1)delete p1;// p2->~A() + operator delete(p2)delete p2;return 0;
}

在这里插入图片描述

多态调用是父类的指针/引用指向哪个类对象就调用哪个类的虚函数；普通的调用是根据指针/引用/对象的类型调用类里面的函数。

加上virtual就不是隐藏了，其实是构成虚函数的重写，进而构成多态。

class A
{
public:virtual ~A(){cout << "~A()" << endl;}
};
class B : public A {
public:// 派生类的析构函数可以不加virtual，但是还是建议加上virtual ~B(){cout << "~B()->delete:" << _p << endl;delete _p;}
protected:int* _p = new int[10];
};
// 只有派生类的析构函数重写了基类的析构函数，下面的delete对象调用析构函数
// 才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{A* p1 = new A;// new了一个A类对象，用A*类型的指针指着A* p2 = new B;// new了一个B类对象，用A*类型的指针指着// p1->destructor + operator delete(p1)delete p1;// p2->destructor + operator delete(p2)delete p2;return 0;
}

在这里插入图片描述

所以若设计一个基类，则它的析构函数前一定要加上virtual，这样是为了避免内存泄漏的问题。例如我们后面要学习到的异常exception，它就是一个标准的基类，它的析构函数前就加了virtual。

在这里插入图片描述

（6）、override 和 final 关键字

从上面可以看出，C++对虚函数重写的要求比较严格，但是有些情况下由于疏忽，比如函数名写错参数写错等导致无法构成重写，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果再来debug会得不偿失，因此C++11提供了override，可以帮助用户检测是否重写。如果我们不想让派生类重写这个虚函数，那么可以用final去修饰。

// 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;
}

// 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;
}

（7）、重载/重写/隐藏的对比

注意：这个概念对比经常考，大家得理解记忆一下。

有些地方也把隐藏叫做重定义。

在这里插入图片描述

三、纯虚函数和抽象类

在虚函数的后面写上 =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;
}

在这里插入图片描述

上面题目运行结果为12bytes，除了_b和_ch成员，还多一个_vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少有一个虚函数表指针，因为一个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称虚表。_vfptr指向虚函数表（一个指针数组），这个指针数组存放的是虚函数指针的数组。（32位下指针大小是4bytes）

在这里插入图片描述

2、多态的原理

（1）、多态是如何实现的

class Person {
public:virtual void BuyTicket() { cout << "买票-全价" << endl; }
private:string _name;
};
class Student : public Person {
public:virtual void BuyTicket() { cout << "买票-打折" << endl; }
private:string _id;
};
class Soldier : public Person {
public:virtual void BuyTicket() { cout << "买票-优先" << endl; }
private: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;
}

在这里插入图片描述

从底层的角度Func函数中ptr->BuyTicket()，是如何作为ptr指向Person对象调用Person::BuyTicket，ptr指向Student对象调用Student::BuyTicket的呢？通过下图我们可以看到，满足多态条件后，底层不再是编译时通过调用对象确定函数的地址，而是运行时到指向的对象的虚表中找对应的虚函数的地址进行调用，这样就实现了指针或引用指向基类就调用基类的虚函数，指向派生类就调用派生类对应的虚函数。第一张图，ptr指向的Person对象，调用的是Person的虚函数；第二张图，ptr指向的Student对象，调用的是Student的虚函数。

父子类对象赋值给基类的指针/引用，由于切割/切片，基类的指针/引用始终指向的是基类成员。

在这里插入图片描述

在这里插入图片描述

虚函数就是为了多态服务的，所以不要总把成员函数定义为虚函数，因为虚函数的地址是要被放进虚函数表的，总有消耗。

普通函数和虚函数编译后都是放在代码段（常量区）的，编译后是一段指令。普通函数的地址不需要用对象存储，因为普通函数的调用都是编译时静态确定它的地址，call一个地址，符号表里找好地址。虚函数是为了是实现多态，编译后把它的第一条指令（函数地址）放在虚函数表，实现指向谁调用谁的虚函数。

（2）、动态绑定与静态绑定

对不满足多态条件(指针或者引用+调用虚函数)的函数调用是在编译时绑定，也就是编译时确定调用函数的地址，叫做静态绑定，也叫做早期绑定。
满足多态条件的函数调用是在运行时绑定，也就是在运行时到指向对象的虚函数表中找到调用函数的地址，也就做动态绑定，也叫做晚绑定。

	// ptr是指针+BuyTicket是虚函数满⾜多态条件。// 这⾥就是动态绑定，编译在运⾏时到ptr指向对象的虚函数表中确定调⽤函数地址ptr->BuyTicket();
00EF2001 mov	eax, dword ptr[ptr]
00EF2004 mov	edx, dword ptr[eax]
00EF2006 mov	esi, esp
00EF2008 mov	ecx, dword ptr[ptr]
00EF200B mov	eax, dword ptr[edx]
00EF200D call	eax// BuyTicket不是虚函数，不满⾜多态条件。// 这⾥就是静态绑定，编译器直接确定调⽤函数地址ptr->BuyTicket();
00EA2C91 mov	ecx, dword ptr[ptr]
00EA2C94 call	Student::Student(0EA153Ch)

（3）、虚函数表

基类对象的虚函数表中存放基类所有虚函数的地址。同类型的对象共用同一张虚表，不同类型的对象各自有独立的虚表，所以基类和派生类有各自独立的虚表，派生类和派生类之间各自有独立的虚表。
派生类由两部分构成，继承下来的基类和自己的成员，一般情况下，继承下来的基类中有虚函数表指针，派生类自己就不会再生成虚函数表指针。但是要注意的这里继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同一个，就像基类对象的成员和派生类对象中的基类对象成员也独立的。
派生类中重写的基类的虚函数，派生类的虚函数表中对应的虚函数就会被覆盖成派生类重写的虚函数地址。
派生类的虚函数表中包含，(1)基类的虚函数地址，(2)派生类重写的虚函数地址完成覆盖，派生类自己的虚函数地址三个部分。
虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个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:// 重写基类的func1virtual 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 b;Derive d;return 0;
}

在这里插入图片描述

虚函数表存放在？根据地址比对，更接近谁就存放在谁那里。

怎么得到虚表的地址（虚函数表指针）？32位下，因为vs中类对象前4个字节就是虚表指针的大小，所以其实虚表指针的地址就是类对象指针。但是要取到虚表指针？
在这里插入图片描述

对于整型变量int i = 1;，怎么取到它的第一个字节？

法一：强制类型转换，大类型转小类型其实是截断的过程。不是任意类型都可以强转的，但是相近类型可以强转：

int i = 1;
char ch = i;
printf("%d\n", ch);// 当然不能按照%c打印，因为ASCII值是1的字符看不见也看不懂。// 小端基，打印结果是1；大端基，打印结果为0

同理，可以把Base强转成int吗？——不能。Base与int不是相近类型，只有相近类型才能强转。

// 这样不行，只有相近类型才能强转
Base b;
int x = (int)b;// error

法二：绕路的方法，不同类型的指针之间是有关联的，因为都是地址。取i的地址强转成char*再解引用就拿到了第一个字节的内容。

int*解引用看4个字节，char*解引用看1个字节。

int i = 1;
int* ptr1 = &i;
char* ptr2 = (char*)ptr1;
printf("%d\n", *ptr2);

同理：

Base b;
Base* p = &b;
printf("%p\n", *((int*)p));// 32位下

在这里插入图片描述

对比发现，虚函数表地址更接近常量区，常量区不能被改变，虚表确定了就不能被改变，也符合常理。

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("Base虚表地址:%p\n", *(int*)p3);printf("Derive虚表地址:%p\n", *(int*)p4);printf("虚函数地址:%p\n", &Base::func1);printf("普通函数地址:%p\n", &Base::func5);return 0;
}