多态基础认识【C++】【虚函数 || 多态面试题 || 多态原理 || 多继承多态】

目录

一，概念 

二，定义

 什么是虚函数

2. 虚函数重写（覆盖）

虚函数重写2个特例 

1. 重写析构函数

2.协变

3.面试题

4.接口继承与实现继承的区别

 5. C++11 override & final

1. final：修饰虚函数，表示该虚函数不能再被重写(用的比较少)

2.override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

6. 重载，重写，重定义之间的区别

7. 抽象类

 三，多态原理

1.概念

2. 实验

3. 验证（比较难）

4.补充动静态绑定

四，多继承多态

五，常见面试题

结语

---

一，概念 

程序中，同一个函数名字可以有多个不同的实现方式，根据函数的参数类型或个数的不同来决定具体调用哪个实现方式的特性。这种特性可以让程序在编译时期无需确定函数具体的实现方式，而是在运行时根据实际情况动态地确定调用哪个实现方式 。

多态的概念：通俗来说，就是多种形态， 具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

二，定义

 那么在继承中要构成多态还有两个条件：

1. 必须通过基类的指针(或引用)调用虚函数。（硬性要求）

2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。

实验代码，尝试有无虚函数的场景

  class Person 
  {
   public:
      virtual void BuyTicket()
      // void BuyTicket()
  8   { cout << "全价" << endl;}
  9 
 10   ~Person(){ cout << "~Person" << endl; }
 11 };
 12 
 13 class Student: public Person 
 14 {
 15   public:
 16   virtual void BuyTicket()
      // void BuyTicket()
 17   { cout << "半价" << endl;}
 18 
 19   ~Student(){cout << "~Student" << endl;}
 20 };
 21 
 22 void func(Person& p1)                                                   
 23 {                                                          
 24   p1.BuyTicket();
 25 }
      int main()                                                 
 28 {
 34  Person p;
 35  func(p);
 36  Student s;
 37  func(s);
 38   return 0;
 39 }
              

 构成多态调用流程：

 

当程序调用一个虚函数时，会根据指针或引用的实际类型来确定调用的是哪个类的虚函数。具体的调用过程如下：

1. 当基类指针或引用调用虚函数时，编译器会根据指针或引用的静态类型找到基类中对应的虚函数。
2. 运行时，程序会根据指针或引用的实际类型找到派生类中重写的虚函数。
3. 如果派生类中没有重写虚函数，则会调用基类中的虚函数。
4. 如果派生类中重写了虚函数，则会调用派生类中的虚函数。（来源chatgpt）

 什么是虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数。

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

virtual 关键词使用

2. 虚函数重写（覆盖）

派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的 返回值类型 、 函数名字 、 参数类型 完全相同)，称子类的虚函数重写了基类的虚函数。

示例，在上个代码已经体现了，这里说2个 特例：

虚函数重写2个特例 

1. 重写析构函数

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。 虽然析构函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

2.协变

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即 基类虚函数返回 基类对象的指针或者引用， 派生类虚函数返回 派生类对象的指针或者引用时，称为协变。从这个特例中，我们就会发现，该 虚函数返回值不同，但也构成多态。（后面我们会解释）

class A {};
class B : public A {};

class Person 
{
public:
	virtual A* fc() { return new A; }
};
class Student : public Person {
public:
	virtual B* fc() { return new B; }
    // 省略virtual 也可以
};

如以上代码可见，返回的两个对象需要是父子关系。

3.面试题

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

解释一下：为啥结果是B->1??? 

 

这里就引出了

4.接口继承与实现继承的区别

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。

虚函数的继承是一种 接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

 5. C++11 override & final

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

1. final：修饰虚函数，表示该虚函数不能再被重写(用的比较少)

class Car
{
public:
 virtual void Drive() final {}
};
class Benz :public Car
{
public:
 virtual void Drive() {cout << "Benz-舒适" << endl;}
};

2.override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

class Car{
  public:
  virtual void Drive(){}
};
class Benz :public Car {
 public:
 virtual void Drive() override {cout << "Benz-舒适" << endl;}
};

6. 重载，重写，重定义之间的区别

7. 抽象类

概念：

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。 包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。（这算是间接监督子类虚函数重写，不然就不能实例化对象）

class A
{
	virtual void func() = 0;
};

class B : public A
{
	void func(){}
};
void main()
{B b;}

 三，多态原理

引出：

// 这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
 virtual void Func1()
 {
 cout << "Func1()" << endl;
 }
private:
 int _b = 1;
};

在VS2019下的结果是：12，不是8哦。这多出来了东西，

就是这次要讲的——虚函数表，而这多出来的4字节是，一个指针。

1.概念

虚函数表是一个存储了虚函数地址的表格，每个对象都有一个指向虚函数表的指针。当调用一个虚函数时，编译器会通过对象的虚函数指针找到对应的虚函数表，并根据函数在虚函数表中的位置来确定调用哪个函数的实现。并且，在程序中使用基类指针或引用指向子类对象时，编译器只能根据指针或引用的类型来确定调用哪个函数，而无法确定实际指向的子类对象的类型。因此，编译器会将虚函数的调用转换为一个虚函数表（vtable）的查找过程，以在运行时动态地确定调用哪个虚函数的实现。（来自chatgpt）

观察下面的代码的运行监视窗口：

2. 实验

class A
{
public:
	virtual void func() {
		cout << "A func";
	}
	
	virtual void test(){
		cout << "A test";
	}

	void KD()
	{
		cout << "KD";
	}
	
	int a;
	char c;
};

class B : public A
{
	virtual void func(){
		cout << "B func";
	 }
	// virtual void test(){}

	virtual void one()
	{
		cout << "B one" << endl;
	}
};

void main()
{  
	A a;
	B b;
	b.KD();
}

观察结果：

(1. 派生类对象b中也有一个虚表指针(且通过查看_vfptr不难发现子父类对象都有各自的虚表)，b对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。

(2.基类a对象和派生类b对象虚表是不一样的( 但同类对象，共用一套虚表，只是里面数据不同)，这里我们发现 Func完成了重写，所以b的虚表中存的是重写的B::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。(可以这么理解，子类重写函数就将重写的函数指针覆盖了父类在虚表上的指针)

(3. 另外B继承下来后是虚函数，所以放进了虚表，KD函数也继承下来了，但是不是虚函数，所以不会放进虚表。

(4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。

(5. 总结一下派生类的虚表生成：

a.先将基类中的虚表内容拷贝一份到派生类虚表中。

b.如果派生类重写了基类中某个虚函数，用派生类自己的 虚函数指针覆盖虚表中基类的 虚函数指针。

c.派生类自己新增加的虚函数按其在派生类中的声明次序增加派生类虚表的最后。

(6. 这里还有一个童鞋们很容易混淆的问题： 虚函数存在哪的？虚表存在哪的？ 答：虚函数存在 虚表，虚表存在对象中。注意上面的回答的错的。但是很多童鞋都是这样深以为然的。注意： 虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外 对象中存的不是虚表，存的是虚表指针。那么 虚表存在哪的 呢？实际我们去验证一下会发现vs下是存在代码段的，Linux g++下大家自己去验证？

3. 验证（比较难）

验证：子类新的虚函数，是否能出现在虚表里？

首先我们观察下面代码:

class A
{
public:
	virtual void func() {cout << "A func";}
	virtual void test(){cout << "A test";}
	int a = 1;
	char c;
};

class B : public A
{
	virtual void func(){ cout << "B func";}
	virtual void one(){ cout << "B one" << endl; }
};

void main()
{  
	A a;
	B b;
}

补充一下函数指针的知识：函数指针类型的定义格式为：返回值类型 (*指针变量名)(参数类型列表)。其中，返回值类型是指被指向函数的返回值类型，参数类型列表是指被指向函数的参数类型列表。

例如：如果有一个函数指针类型为void (*FuncPtr)()，可以使用typedef关键字为该类型定义一个新的名称，如typedef void (*NewFuncPtr)()。然后，可以使用NewFuncPtr来声明函数指针变量，如NewFuncPtr ptr = func;，其中func是一个与函数指针类型匹配的函数。（来源chatgpt）

实验代码如下:

typedef void (*VFP)(); // 重命名函数指针类型，为VFP
// 制作一个便利虚表的函数，通过一般情况这个数组最后面放了一个nullptr，就可判断结束条件
void VFP_table(VFP* _vfp) // 本质上是一个二级指针
{ 
	for (int i = 0;  _vfp[i] != nullptr ; i++)
	{
		printf("VFP[%d]->%p 调用结果： ", i, _vfp[i]);
		VFP instruction = _vfp[i];
		instruction();
		cout << endl;
	}
	cout << endl;
}

void main()
{  
	A a;
	B b;
    // 利用虚表存放在基类数据的前4个字节（或8字节)
	VFP_table((VFP*)(*(int*)(&a)));//局限性x64地址有8位，这里的int得换成long long
	VFP_table(*(VFP**)&b);// 比较简单的理解是，接口需要2级指针，这里有三级，解引用1级
}

感兴趣的同学可以自己画图。

结果呢？

结果：是我们访问到了那个在监视窗口中未曾可视的虚函数，监视窗口只是隐藏了。被virtual 的虚函数指针都会在虚表中。

4.补充动静态绑定

1. 静态绑定又称为前期绑定(早绑定)， 在程序编译期间确定了程序的行为， 也称为静态多态，比如：函数重载

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);
 VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d+sizeof(Base1)));
 PrintVTable(vTableb2);
 return 0;
}

 结果分析：

由上图可知：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中  

菱形继承，简单展示 

具体想了解，请移步大佬文章：C++ 虚函数表解析 | 酷 壳 - CoolShell

这边建议，菱形虚拟继承与多态融合不用深入研究，容易走火入魔！

五，常见面试题

1. inline 函数可以是虚函数吗？答：可以，不过编译器就忽略 inline 属性，这个函数就不再是inline，因为虚函数要放到虚表中去。

2. 静态成员可以是虚函数吗？答：不能，因为静态成员函数没有 this 指针，使用类型 :: 成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

3. 构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。

4. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以，并且最好把基类的析构函数定义成虚函数。

5. 对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函表中去查找。（注意：通过指针或引用，调用虚函数，如果没有构成多态，则这次调用叫做：多态调用，函数也是从虚表中查询）

6. 虚函数表是在什么阶段生成的，存在哪的？答：虚函数表是在编译阶段就生成的，一般情况下存在代码段( 常量区 ) 的。

7. C++菱形继承的问题？虚继承的原理？答：参考继承课件。注意这里不要把虚函数表和虚基表搞混了。

8. 什么是抽象类？抽象类的作用？答：参考（ 3. 抽象类）。抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。

结语

   本小节就到这里了，感谢小伙伴的浏览，如果有什么建议，欢迎在评论区评论，如果给小伙伴带来一些收获请留下你的小赞，你的点赞和关注将会成为博主创作的动力