【C++】深入浅出之多态

目录

• 多态的概念
• 多态的定义和实现
• • 多态的构造条件
  • 虚函数
  • 虚函数的重写
  • 虚函数重写的两个例外
  • • 协变
    • 析构函数作为虚函数重写
  • C++11的override和final
  • 重载、重写(覆盖)、隐藏(重定义)的对比
  • 相关面试题⭐
• 抽象类
• • 概念
  • 接口继承和实现继承
• 多态的原理
• • 虚函数表
  • 多态的原理
  • 动态绑定和静态绑定
• end

多态的概念

多态就是函数调用的时候的多种形态，不同的对象去做同一件事情会有不同的结果，这就叫做多态

• 例如，在现实生活当中，普通人买票是全价，学生买票是半价，而军人允许优先买票。不同身份的人去买票，所产生的行为是不同的，这就是所谓的多态。

多态的定义和实现

多态的构造条件

多态是指不同继承关系的类对象，去调用同一函数，产生了不同的行为。在继承中要想构成多态需要满足两个条件：

• 必须通过基类的指针或者引用调用虚函数。
• 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。

虚函数

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

class Person
{
public:
	//被virtual修饰的类成员函数
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};

• 需要注意的是：
• 只有类的非静态成员函数前可以加virtual，普通函数前不能加virtual。
• 虚函数这里的virtual和虚继承中的virtual是同一个关键字，但是它们之间没有任何关系。虚函数这里的virtual是为了实现多态，而虚继承的virtual是为了解决菱形继承的数据冗余和二义性。

虚函数的重写

• 虚函数的重写也叫做虚函数的覆盖，若派生类中有一个和基类完全相同的虚函数(返回值类型相同、函数名相同以及参数列表完全相同)，此时我们称该派生类的虚函数重写了基类的虚函数。

例如，我们以下Student和Soldier两个子类重写了父类Person的虚函数。

//父类
class Person
{
public:
	//父类的虚函数
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};
//子类
class Student : public Person
{
public:
	//子类的虚函数重写了父类的虚函数
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};
//子类
class Soldier : public Person
{
public:
	//子类的虚函数重写了父类的虚函数
	virtual void BuyTicket()
	{
		cout << "优先-买票" << endl;
	}
};

• 现在我们就可以通过父类Person的指针或者引用调用虚函数BuyTicket，此时不同类型的对象，调用的就是不同的函数，产生的也是不同的结果，进而实现了函数调用的多种形态。
• 这里为啥要用基类指针才可以？表面上是基类指针即可以指向基类对象也可以指向派生类对象，深层是后面多态的原理：基类指针可以找到父类和子类对象的虚表指针（后面多态原理会讲）

void Func(Person& p)
{
	//通过父类的引用调用虚函数
	p.BuyTicket();
}
void Func(Person* p)
{
	//通过父类的指针调用虚函数
	p->BuyTicket();
}
int main()
{
	Person p;   //普通人
	Student st; //学生
	Soldier sd; //军人

	Func(p);  //买票-全价
	Func(st); //买票-半价
	Func(sd); //优先买票

	Func(&p);  //买票-全价
	Func(&st); //买票-半价
	Func(&sd); //优先买票
	return 0;
}

注意： 在重写基类虚函数时，派生类的虚函数不加virtual关键字也可以构成重写，主要原因是因为继承后基类的虚函数被继承下来了，在派生类中依旧保持虚函数属性(注意这个词哦，后面有道题这个坑)。但是这种写法不是很规范，因此建议在派生类的虚函数前也加上virtual关键字。

虚函数重写的两个例外

协变

协变（基类与派生类虚函数的返回值类型不同）

• 派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用，称为协变。
• 例如，下列代码中基类Person当中的虚函数fun的返回值类型是基类A对象的指针，派生类Student当中的虚函数fun的返回值类型是派生类B对象的指针，此时也认为派生类Student的虚函数重写了基类Person的虚函数。

//基类
class A
{};
//子类
class B : public A
{};
//基类
class Person
{
public:
	//返回基类A的指针
	virtual A* fun()
	{
		cout << "A* Person::f()" << endl;
		return new A;
	}
};
//子类
class Student : public Person
{
public:
	//返回子类B的指针
	virtual B* fun()
	{
		cout << "B* Student::f()" << endl;
		return new B;
	}
};

• 此时，我们通过父类Person的指针调用虚函数fun，父类指针若指向的是父类对象，则调用父类的虚函数，父类指针若指向的是子类对象，则调用子类的虚函数。

int main()
{
	Person p;
	Student st;
	//父类指针指向父类对象
	Person* ptr1 = &p;
	//父类指针指向子类对象
	Person* ptr2 = &st;
	//父类指针ptr1指向的p是父类对象，调用父类的虚函数
	ptr1->fun(); //A* Person::f()
	//父类指针ptr2指向的st是子类对象，调用子类的虚函数
	ptr2->fun(); //B* Student::f()
	return 0;
}

析构函数作为虚函数重写

• 那父类和子类的析构函数构成重写的意义何在呢？试想以下场景：分别new一个父类对象和子类对象，并均用父类指针指向它们，然后分别用delete调用析构函数并释放对象空间。

//父类
class Person
{
public:
	virtual ~Person()
	{
		cout << "~Person()" << endl;
	}
};
//子类
class Student : public Person
{
public:
	virtual ~Student()
	{
		cout << "~Student()" << endl;
	}
pivate:
	int * p = new int[10];
};

int main()
{
	//分别new一个父类对象和子类对象，并均用父类指针指向它们
	Person* p1 = new Person;
	Person* p2 = new Student;

	//使用delete调用析构函数并释放对象空间
	delete p1;
	delete p2;
	return 0;
}

• 在这种场景下，若是父类和子类的析构函数没有构成重写就会导致内存泄漏，因为此时delete p1和delete p2都是调用的父类的析构函数，派生类student的p指针并没有通过调用派生类的析构函数来释放空间/mark>，而我们所期望的是p1调用父类的析构函数，p2调用子类的析构函数，即我们期望的是一种多态行为。
• 此时只有父类和子类的析构函数构成了重写，才能使得delete按照我们的预期进行析构函数的调用，才能实现多态。因此，为了避免出现这种情况，比较建议将父类的析构函数定义为虚函数。
• 现在多态的第一个条件基类的指针或引用已经有了，还差一个重写。重写要求同名，同返回值，同参数列表，我们的析构函数只有同名不满足，所以编译器编译的时候会强制把所有析构函数的名字替换为destructort，所以基类的析构函数加了 vialtual修饰，派⽣类的析构函数就构成重写。
• 知识扩展：
  在继承当中，子类和的析构函数和父类的析构函数构成隐藏的原因就在这里，这里表面上看子类的析构函数和父类的析构函数的函数名不同，但是为了构成重写，编译后析构函数的名字会被统一处理成destructor();。

C++11的override和final

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

final：修饰虚函数，表示该虚函数不能再被重写。

• 例如，父类Person的虚函数BuyTicket被final修饰后就不能再被重写了，子类若是重写了父类的BuyTicket函数则编译报错。

//父类
class Person
{
public:
	//被final修饰，该虚函数不能再被重写
	virtual void BuyTicket() final
	{
		cout << "买票-全价" << endl;
	}
};
//子类
class Student : public Person
{
public:
	//重写，编译报错
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};
//子类
class Soldier : public Person
{
public:
	//重写，编译报错
	virtual void BuyTicket()
	{
		cout << "优先-买票" << endl;
	}
};

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

• 例如，子类Student和Soldier的虚函数BuyTicket被override修饰，编译时就会检查子类的这两个BuyTicket函数是否重写了父类的虚函数，如果没有则会编译报错。

//父类
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};
//子类
class Student : public Person
{
public:
	//子类完成了父类虚函数的重写，编译通过
	virtual void BuyTicket() override
	{
		cout << "买票-半价" << endl;
	}
};
//子类
class Soldier : public Person
{
public:
	//子类没有完成了父类虚函数的重写，因为重写要求参数列表相同，编译报错
	virtual void BuyTicket(int i) override
	{
		cout << "优先-买票" << endl;
	}
};

重载、重写(覆盖)、隐藏(重定义)的对比

相关面试题⭐

• 1.这里派生类的指针去调用public继承下来的基类函数test, 那么test里面又去调用func, this(A*，j基类)指针调用func, 那么这里满足多态吗？
• 多态两个条件
  (1)：要实现多态效果，第⼀必须是基类的指针或引⽤，因为只有基类的指针或引⽤才能既指向基类对象也可以指向派⽣类对象(切片)；这里已经满足了(this指针(A*)基类指针调用虚函数)
  (2)第⼆派⽣类必须对基类的虚函数重写/覆盖，重写或者覆盖了，派⽣类才能有不同的函数，多态的不同形态效果才能达到。这里也达到了把，func函数在基类和派生类的i函数名，返回值，形参列表完全一致，就是那个缺省参数值不一样。但是参数列表只要是缺省参数值类型和名字相同就行了，并没有规定缺省值相同,
• 注意：在重写基类虚函数时，派⽣类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派⽣类依旧保持虚函数属性)，但是该种写法不是很规范，不建议这样 使⽤.
• 有的人就说了，那肯定是选D了，那么这里的派生类指针去调用test传过去指向派生类对象，就去调用派生类的重写虚函数，那么应该是B->0呀，派生类里面的缺省值不是0吗，所以我们前面标注的重写相当于继承属性这个是什么属性，实际上就是把基类的虚函数的缺省值属性拿下来用，基类的虚函数缺省值是1。所以选B
• 注意：只有多态才是这样的结果，所以这道题也警告我们，重写虚函数构成多态的时候不要让重写虚函数的基类和派生类的缺省值不一样

抽象类

概念

• 在虚函数的后面写上=0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。

#include <iostream>
using namespace std;
//抽象类（接口类）
class Car
{
public:
	//纯虚函数
	virtual void Drive() = 0;
};
int main()
{
	Car c; //抽象类不能实例化出对象，error
	return 0;
}

• 派生类继承抽象类后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。

#include <iostream>
using namespace std;
//抽象类（接口类）
class Car
{
public:
	//纯虚函数
	virtual void Drive() = 0;
};
//派生类
class Benz : public Car
{
public:
	//重写纯虚函数
	virtual void Drive()
	{
		cout << "Benz-舒适" << endl;
	}
};
//派生类
class BMV : public Car
{
public:
	//重写纯虚函数
	virtual void Drive()
	{
		cout << "BMV-操控" << endl;
	}
};
int main()
{
	//派生类重写了纯虚函数，可以实例化出对象
	Benz b1;
	BMV b2;
	//不同对象用基类指针调用Drive函数，完成不同的行为
	Car* p1 = &b1;
	Car* p2 = &b2;
	p1->Drive();  //Benz-舒适
	p2->Drive();  //BMV-操控
	return 0;
}

抽象类既然不能实例化出对象，那抽象类存在的意义是什么？

• 抽象类可以更好的去表示现实世界中，没有实例对象对应的抽象类型，比如：植物、人、动物等。
• 抽象类很好的体现了虚函数的继承是一种接口继承，强制子类去重写纯虚函数，因为子类若是不重写从父类继承下来的纯虚函数，那么子类也是抽象类也不能实例化出对象。

接口继承和实现继承

• 实现继承：普通函数继承下来就是一个实现继承，派生类继承了基类函数的实现，可以使用该函数
• 接口继承：虚函数的继承就是一种接口继承，派生类继承的是虚函数的接口，目的是为了完成重写，实现多态

多态的原理

虚函数表

下面是一道常考的笔试题：Base类实例化出对象的大小是多少？

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};

• 通过观察测试，我们发现Base类实例化的对象b的大小是8个字节。(内存对齐，参考这篇内存对齐详解
• b对象当中除了_b成员外，实际上还有一个_vfptr放在对象的前面（有些平台可能会放到对象的最后面，这个跟平台有关）。
  
• 对象中的这个指针叫做虚函数表指针，简称虚表指针，虚表指针指向一个虚函数表，简称虚表，每一个含有虚函数的类中都至少有一个虚表指针。

虚函数表中到底放的是什么？

• 下面Base类当中有三个成员函数，其中Func1和Func2是虚函数，Func3是普通成员函数，子类Derive当中仅对父类的Func1函数进行了重写。

#include <iostream>
using namespace std;
//父类
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:
	//重写虚函数Func1
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};
int main()
{
	Base b;
	Derive d;
	return 0;
}

• 通过调试可以看到，父类和子类对象都有一个虚表指针，分别指向属于自己的虚表。
  
• 实际上虚表当中存储的就是虚函数的地址，因为父类当中的Func1和Func2都是虚函数，所以父类对象b的虚表当中存储的就是虚函数Func1和Func2的地址。(注意虚函数表只会存储虚函数的地址，普通函数的地址并不会存储)
• 而子类继承了基类的3个函数，其中有两个虚函数Func1和Func2,但是子类对父类的虚函数Func1进行了重写，可以看到重写后的Func1在子类中的地址和在父类中Func1的地址是不一样的，而在子类中没有重写的Func2地址跟在父类中的Func2的地址一样，这就是为什么虚函数的重写也叫做覆盖，覆盖就是指虚表中虚函数地址的覆盖，重写是语法的叫法，覆盖是原理层的叫法。

总结一下，派生类的虚表生成步骤如下：

• 把基类中的虚函数表的虚函数copy一份放在子类的虚函数表中
• 如果派生类重写了基类中的某个虚函数，则用派生类自己的虚函数地址覆盖虚表中基类的虚函数地址。

虚表是什么阶段初始化的？虚函数存在哪里？虚表存在哪里？

• 1.虚表实际上是在构造函数初始化列表阶段初始化的，注意虚表中存储的不是虚函数，而是虚函数的地址
• 虚函数和普通函数一样，都是存储在代码段的。只是他的地址又存在在了虚表中，另外对象中存储的不是虚表，而是指向虚表的指针。
• 虚表是什么阶段初始化的？虚函数存在哪里？虚表存在哪里？

int j = 0;
int main()
{
	Base b;
	Base* p = &b;
	printf("vfptr:%p\n", *((int*)p)); //000FDCAC
	int i = 0;
	printf("栈上地址:%p\n", &i);       //005CFE24
	printf("数据段地址:%p\n", &j);     //0010038C

	int* k = new int;
	printf("堆上地址:%p\n", k);       //00A6CA00
	char* cp = "hello world";
	printf("代码段地址:%p\n", cp);    //000FDCB4
	return 0;
}

• 代码当中打印了对象b当中的虚表指针，也就是虚表的地址，可以发现虚表地址与代码段的地址非常接近，由此我们可以得出虚表实际上是存在代码段的。

多态的原理

那到底多态的原理是什么？

例如，下面代码中，为什么当父类Person指针指向的是父类对象Mike时，调用的就是父类的BuyTicket，当父类Person指针指向的是子类对象Johnson时，调用的就是子类的BuyTicket?

#include <iostream>
using namespace std;
//父类
class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
	int _p = 1;
};
//子类
class Student : public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
	int _s = 2;
};
int main()
{
	Person Mike;
	Student Johnson;
	Johnson._p = 3; //以便观察是否完成切片
	Person* p1 = &Mike;
	Person* p2 = &Johnson;
	p1->BuyTicket(); //买票-全价
	p2->BuyTicket(); //买票-半价
	return 0;
}

• 通过调试可以发现，Mike对象中包含一个成员变量_p和一个虚表指针，对象Johnson中包含两个成员变量_p和_s以及一个虚表指针，这两个对象当中的虚表指针分别指向自己的虚表。
  
• 围绕此图分析便可得到多态的原理：
• 父类指针指向Mike对象，p1->BuyTicket在Mike的虚表中找到的虚函数就是Person::BuyTicket。
• 父类指针p2指向Johnson对象，p2>BuyTicket在Johnson的虚表中找到的虚函数就是Student::BuyTicket。

这样就实现出了不同对象去完成同一行为时，展现出不同的形态。

现在想一下多态的两个条件。一个是完成虚函数的重写，这个是为了我们使用两个类虚表中的虚函数的时候，对子类虚表中的虚函数地址进行覆盖，达到同一个函数不同结果，所以我们要重写。那么为啥必须是基类的指针呢？能不能是基类对象呢？

Person* p1 = &Mike;
Person* p2 = &Johnson;

• 使用父类的指针或引用的时候，我们在继承那说过，实际上基类的指针和引用会把在子类对象中基类那部分切片，就是指向或引用子类中基类的那部分
  
• 这里我们就要补充一个很重要的概念，不同类中的虚表是不一样的，所以我们虽说是继承下来基类的虚表，指向基类的那部分有虚表，但是我们的虚表和基类是不一样的。
• 因此，我们后序用p1和p2调用虚函数时，p1和p2通过虚表指针找到的虚表是不一样的，最终调用的函数也是不一样的。

Person p1 = Mike;
Person p2 = Johnson;

• 那么基类对象为啥就不行呢？这里如果我们想给p1和p2两个父类对象赋值，就要去调用父类拷贝构造，拷贝构造出来两个父类对象，刚刚说了，同一个类的虚函数表是同一个。那么他们的虚表指针是指向同一个虚函数表
  

• 因此，我们后序用p1和p2调用虚函数时，p1和p2通过虚表指针找到的虚表是一样的，最终调用的函数也是一样的，也就无法构成多态。

• 前面的指针和引用，指针指向父类对象，引用通过切片引用的是派生类中的基类部分，实际上类型还是一个派生类，所以他们类型不同，虚表指针指向两个不同的虚表。

动态绑定和静态绑定

• 静态绑定，就是只在编译的时候就进行了多态变化，也成为静态多态，比如：函数重载。
• 动态绑定，就出指在运行的时候进行了多态变化，我们今天说的就是动态的多态。

end

好了，多态这部分就说完了，谢谢你的阅读，希望多你有帮助