• 机械转码日记【25】多态

    目录

    前言

    1.多态的概念 

    2. 多态的定义及实现

    2.1多态的构成条件 

    2.2 虚函数 

    2.3虚函数的重写

    2.4虚函数重写的两个例外

    2.4 C++11 override 和 final

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

    3.抽象类

    3.1概念 

     3.2 接口继承和实现继承

    4.多态的原理

    4.1虚函数表

    4.2多态的原理 

    4.3 动态绑定与静态绑定 

    5.单继承和多继承关系的虚函数表 

    5.1 单继承中的虚函数表

    5.2 多继承中的虚函数表

    面试题：

    1

    前言

    前面提到过，C++面向对象的三大特性，封装，继承，多态。这篇博客我们就来讲一下多态

    1.多态的概念 

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

    举个栗子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人 买票时是优先买票。 

    2. 多态的定义及实现

    2.1多态的构成条件 

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

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

    1. 必须通过基类的指针或者引用调用虚函数
    2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写（三同：基类和派生类的函数名&参数&返回值相同）

    2.2 虚函数 

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

    1. class Person
    2. {
    3. public:
    4. 	//虚函数
    5. 	virtual void BuyTicket()
    6. 	{
    7. 		cout << "person买票-全价 100元" << endl;
    8. 	}
    9. };

    2.3虚函数的重写

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

    1. class Person
    2. {
    3. public:
    4. 	//虚函数
    5. 	virtual void BuyTicket()
    6. 	{
    7. 		cout << "person买票-全价 100元" << endl;
    8. 	}
    9. };
    10.  
    11. class Student:public Person
    12. {
    13. public:
    14. 	// 虚函数 + 函数名/参数/返回值 -》 重写/覆盖
    15. 	virtual void BuyTicket()
    16. 	{
    17. 		cout << "student买票-半价 50元" << endl;
    18. 	}
    19. };
    20.  
    21.  
    22. class Soldier :public Person
    23. {
    24. public:
    25. 	// 虚函数 + 函数名/参数/返回值 -》 重写/覆盖
    26. 	virtual void BuyTicket()
    27. 	{
    28. 		cout << "Soldier买票-全价 100元,军人优先" << endl;
    29. 	}
    30. };

    虚函数重写的注意事项：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用。

    1. class Person
    2. {
    3. public:
    4. 	//虚函数
    5. 	virtual void BuyTicket()
    6. 	{
    7. 		cout << "person买票-全价 100元" << endl;
    8. 	}
    9. };
    10.  
    11. class Student:public Person
    12. {
    13. public:
    14. 	// 虚函数 + 函数名/参数/返回值 -》 重写/覆盖
    15. 	virtual void BuyTicket()
    16. 	{
    17. 		cout << "student买票-半价 50元" << endl;
    18. 	}
    19. };
    20.  
    21.  
    22. class Soldier :public Person
    23. {
    24. public:
    25. 	// 虚函数 + 函数名/参数/返回值 -》 重写/覆盖
    26. 	void BuyTicket()//基类不加virtul修饰也不会出错
    27. 	{
    28. 		cout << "Soldier买票-全价 100元,军人优先" << endl;
    29. 	}
    30. };

     下面我们就来实现多态：

    1. class Person
    2. {
    3. public:
    4. 	Person(const char* name)
    5. 		:_name(name)
    6. 	{}
    7. 	//虚函数
    8. 	virtual void BuyTicket()
    9. 	{
    10. 		cout << "person买票-全价 100元" << endl;
    11. 	}
    12.  
    13. protected:
    14. 	string _name;
    15. };
    16.  
    17. class Student :public Person
    18. {
    19. public:
    20. 	Student(const char* name)
    21. 		:Person(name)
    22. 	{}
    23. 	// 虚函数 + 函数名/参数/返回值 -》 重写/覆盖
    24. 	virtual void BuyTicket()
    25. 	{
    26. 		cout << "student买票-半价 50元" << endl;
    27. 	}
    28. };
    29.  
    30.  
    31. class Soldier :public Person
    32. {
    33. public:
    34.  
    35. 	Soldier(const char* name)
    36. 		:Person(name)
    37. 	{}
    38. 	// 虚函数 + 函数名/参数/返回值 -》 重写/覆盖
    39. 	//void BuyTicket()//基类不加virtul修饰也不会出错
    40. 	virtual void BuyTicket()
    41. 	{
    42. 		cout << "Soldier买票-全价 100元,军人优先" << endl;
    43. 	}
    44. };
    45.  
    46. // 多态两个要求：
    47. // 1、子类虚函数重写的父类虚函数 （重写：三同（函数名/参数/返回值）+虚函数）
    48. // 2、父类指针或者引用去调用虚函数。
    49.  
    50. void Pay(Person* ptr)
    51. {
    52. 	ptr->BuyTicket();
    53. }
    54.  
    55. void Pay(Person& ptr)
    56. {
    57. 	ptr.BuyTicket();
    58. }
    59.  
    60. // 不能构成多态
    61. //void Pay(Person ptr)
    62. //{
    63. //	ptr.BuyTicket();
    64. //}
    65.  
    66.  
    67. int main()
    68. {
    69. 	int option = 0;
    70. 	cout << "=======================================" << endl;
    71. 	do
    72. 	{
    73. 		cout << "请选择身份：";
    74. 		cout << "1、普通人 2、学生 3、军人" << endl;
    75. 		cin >> option;
    76. 		cout << "请输入名字：";
    77. 		string name;
    78. 		cin >> name;
    79. 		switch (option)
    80. 		{
    81. 		case 1:
    82. 		{
    83. 			Person p(name.c_str());
    84. 			Pay(p);
    85. 			break;
    86. 		}
    87. 		case 2:
    88. 		{
    89. 			Student s(name.c_str());
    90. 			Pay(s);
    91. 			break;
    92. 		}
    93. 		case 3:
    94. 		{
    95. 			Soldier s(name.c_str());
    96. 			Pay(s);
    97. 			break;
    98. 		}
    99. 		default:
    100. 			cout << "输入错误,请重新输入" << endl;
    101. 			break;
    102. 		}
    103. 		cout << "=======================================" << endl;
    104. 	} while (option != -1);
    105.  
    106. 	return 0;
    107. }

    从代码可以看到我们是用父类的引用去调用虚函数，同时类中买票的这个函数也是一个虚函数，并且堆虚函数进行类重写（三同，函数名&参数&返回值都相同），这就构成了多态。

    2.4虚函数重写的两个例外

    1. 协变(基类与派生类虚函数返回值类型不同) 

    1. class A {};
    2. class B : public A {};
    3.  
    4. class Person
    5. {
    6. public:
    7. 	virtual A* f()
    8. 	{
    9. 		return new A;
    10. 	}
    11. };
    12.  
    13. class Student : public Person
    14. {
    15. public:
    16. 	virtual B* f()
    17. 	{
    18. 		return new B;
    19. 	}
    20. };

    派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指 针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。协变简单来说就是父类返回父类对象的指针或引用，子类返回子类对象的指针或引用。

    2. 析构函数的重写(基类与派生类析构函数的名字不同)

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

    1. class Person {
    2. public:
    3. 	virtual ~Person() { cout << "~Person()" << endl; }
    4. };
    5. class Student : public Person {
    6. public:
    7. 	virtual ~Student() { cout << "~Student()" << endl; }
    8. };
    9. // 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函
    10. //数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
    11. int main()
    12. {
    13. 	Person* p1 = new Person;
    14. 	Person* p2 = new Student;
    15.  
    16. 	delete p1;
    17. 	delete p2;
    18.  
    19. 	return 0;
    20. }

    2.4 C++11 override 和 final

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

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

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

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

    3.抽象类

    3.1概念 

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

    1. class Car
    2. {
    3. public:
    4. 	virtual void Drive() = 0;
    5. };
    6. class Benz :public Car
    7. {
    8. public:
    9. 	virtual void Drive()
    10. 	{
    11. 		cout << "Benz-舒适" << endl;
    12. 	}
    13. };
    14. class BMW :public Car
    15. {
    16. public:
    17. 	virtual void Drive()
    18. 	{
    19. 		cout << "BMW-操控" << endl;
    20. 	}
    21. };
    22. void Test()
    23. {
    24. 	Car* pBenz = new Benz;
    25. 	pBenz->Drive();
    26. 	Car* pBMW = new BMW;
    27. 	pBMW->Drive();
    28. }

     3.2 接口继承和实现继承

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

    4.多态的原理

    4.1虚函数表

     我们由一个问题引入虚函数表， 请问下面的代码中，sizeof(Base)是多少？

    1. class Base
    2. {
    3. public:
    4. 	virtual void Func1()
    5. 	{
    6. 		cout << "Func1()" << endl;
    7. 	}
    8.  
    9. private:
    10. 	int _b = 1;
    11. };

    运行结果是8，你肯定会有所疑问，不是说类的成员函数不占用空间吗？这里只有一个int类型的成员变量，结果应该是4啊，其实不然，除了_b成员，还多一个__vfptr放在对象的前面(注意有些 平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

     那么派生类中这个表放了些什么呢？我们接着往下分析：

    1. // 针对上面的代码我们做出以下改造
    2. // 1.我们增加一个派生类Derive去继承Base
    3. // 2.Derive中重写Func1
    4. // 3.Base再增加一个虚函数Func2和一个普通函数Func3
    5. class Base
    6. {
    7. public:
    8. 	virtual void Func1()
    9. 	{
    10. 		cout << "Base::Func1()" << endl;
    11. 	}
    12. 	virtual void Func2()
    13. 	{
    14. 		cout << "Base::Func2()" << endl;
    15. 	}
    16. 	void Func3()
    17. 	{
    18. 		cout << "Base::Func3()" << endl;
    19. 	}
    20. private:
    21. 	int _b = 1;
    22. };
    23. class Derive : public Base
    24. {
    25. public:
    26. 	virtual void Func1()
    27. 	{
    28. 		cout << "Derive::Func1()" << endl;
    29. 	}
    30. private:
    31. 	int _d = 2;
    32. };
    33. int main()
    34. {
    35. 	Base b;
    36. 	Derive d;
    37. 	return 0;
    38. }

    可以看到b对象和d对象的虚表里存了下面这些东西：

    通过观察和测试，我们发现了以下几点问题：

    1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，另一部分是自己的成员。
    2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
    3. Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函 数，所以不会放进虚表。
    4. 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己 新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

    4.2多态的原理 

    通过上面的分析，我们可以再来问自己，多态的原理是什么？ 

    其实p指针也不知道自己要调用哪个类的函数，它只是从类的虚表里面找到那个函数，根据虚表中存的函数地址去调用对应的函数。

     我们再来看看多态调用和普通调用有什么区别：

    1. class Base
    2. {
    3. public:
    4. 	virtual void Func1()
    5. 	{
    6. 		cout << "Base::Func1()" << endl;
    7. 	}
    8. 	virtual void Func2()
    9. 	{
    10. 		cout << "Base::Func2()" << endl;
    11. 	}
    12. 	void Func3()
    13. 	{
    14. 		cout << "Base::Func3()" << endl;
    15. 	}
    16. private:
    17. 	int _b = 1;
    18. };
    19. class Derive : public Base
    20. {
    21. public:
    22. 	virtual void Func1()
    23. 	{
    24. 		cout << "Derive::Func1()" << endl;
    25. 	}
    26.  
    27. 	void Func3()
    28. 	{
    29. 		cout << "Derive::Func3()" << endl;
    30. 	}
    31. private:
    32. 	int _d = 2;
    33. };
    34. int main()
    35. {
    36. 	Base b;
    37. 	Derive d;
    38. 	
    39. 	Base* p = &b;
    40. 	p->Func1();//多态调用
    41. 	p->Func3();//普通调用
    42.  
    43. 	p = &d;
    44. 	p->Func1();//多态调用
    45. 	p->Func3();//普通调用
    46.  
    47. 	return 0;
    48.  
    49. }

    以上代码运行结果可以看到，多态调用成功实现了多态，但是普通调用调的都是父类的函数

     从汇编代码的角度再来分析一下：

    多态调用其实是运行时决议：它指的是运行时确定调用函数的地址

    普通调用其实是编译时决议：它指的是编译时确定调用函数的地址

    因此可以看到多态调用的汇编代码比较长，这实际上都是在查虚函数表，而普通调用早已在编译时就确定了调用函数的地址，因此需要操作的步骤少。

    再来思考一下，为什么多态需要父类的指针和引用去调用成员函数，但是父类对象去调用成员函数就不能实现多态？

    对象切片：对象切片的时候，子类只会拷贝成员给父类对象，不会拷贝虚表指针，如果拷贝就乱套了，父类对象中到底时父类的虚表指针和子类的虚表指针都会有可能，那么下面调用是调用父类的虚函数还是子类的虚函数？就不确定了：

    1. ptr = &b;
    2. ptr->func1();

    指针和引用的切片不一样，引用和指针如果发生切割，它们指向的地方或者别名都是父类中的那一部分，并不会像对象一样有拷贝虚表指针的问题。所以对象不能实现多态，这涉及到对父子类虚函数表处理的问题。

    4.3 动态绑定与静态绑定 

    1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态， 比如：函数重载
    2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。 

    5.单继承和多继承关系的虚函数表 

    5.1 单继承中的虚函数表

    我们看看下面代码中(单继承)的虚函数表

    1. class Base 
    2. {
    3. public:
    4. 	virtual void func1() { cout << "Base::func1" << endl; }
    5. 	virtual void func2() { cout << "Base::func2" << endl; }
    6. private:
    7. 	int a;
    8. };
    9. class Derive :public Base 
    10. {
    11. public:
    12. 	virtual void func1() { cout << "Derive::func1" << endl; }
    13. 	virtual void func3() { cout << "Derive::func3" << endl; }
    14. 	virtual void func4() { cout << "Derive::func4" << endl; }
    15. private:
    16. 	int b;
    17. };
    18.  
    19. int main()
    20. {
    21. 	Base b;
    22. 	Derive d;
    23. }

    下面是调试时调用的监视窗口：

    我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。那么我们如何查看d的虚表呢？下面我们使用代码打印出虚表中的函数。

    1. // 取内存值，打印并调用，确认是否是func4
    2. //typedef void(*)() V_FUNC; // 不支持
    3. typedef void(*V_FUNC)();//函数指针V_FUNC是一个无参数，无返回值的函数指针
    4. // 打印虚表
    5. //void PrintVFTable(V_FUNC a[])
    6. void PrintVFTable(V_FUNC* a)
    7. {
    8. 	printf("vfptr:%p\n", a);
    9. 	for (size_t i = 0; a[i] != nullptr; ++i)
    10. 	{
    11. 		printf("[%d]:%p->", i, a[i]);
    12. 		V_FUNC f = a[i];
    13. 		f();
    14. 	}
    15. }
    16. // 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数
    17. //指针的指针数组，这个数组最后面放了一个nullptr
    18. // 1.先取b的地址，强转成一个int*的指针
    19. // 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
    20. // 3.再强转成V_FUNC*，因为虚表就是一个存V_FUNC类型(虚函数指针类型)的数组。
    21. // 4.虚表指针传递给PrintVFTable进行打印虚表
    22. // 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最
    23. //后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再编译就好了。

    上面就是单继承子类的虚函数表，分为两部分，一部分是父类继承下来的虚函数表（如果子类对父类的某个虚函数进行了重写，就会进行覆盖操作），剩下的一部分是子类自己定义的虚函数地址，也会存在虚表里。

    5.2 多继承中的虚函数表

    建立以下多继承模型：

    1. class Base1 {
    2. public:
    3. 	virtual void func1() { cout << "Base1::func1" << endl; }
    4. 	virtual void func2() { cout << "Base1::func2" << endl; }
    5. private:
    6. 	int b1;
    7. };
    8.  
    9. class Base2 {
    10. public:
    11. 	virtual void func1() { cout << "Base2::func1" << endl; }
    12. 	virtual void func2() { cout << "Base2::func2" << endl; }
    13. private:
    14. 	int b2;
    15. };
    16.  
    17. class Derive : public Base1, public Base2 {
    18. public:
    19. 	virtual void func1() { cout << "Derive::func1" << endl; }
    20. 	virtual void func3() { cout << "Derive::func3" << endl; }
    21. private:
    22. 	int d1;
    23. };

     通过监视窗口我们可以看到d有两个虚表：

     使用以下程序打印出d的虚表

    1. class Base1 {
    2. public:
    3. 	virtual void func1() { cout << "Base1::func1" << endl; }
    4. 	virtual void func2() { cout << "Base1::func2" << endl; }
    5. private:
    6. 	int b1;
    7. };
    8.  
    9. class Base2 {
    10. public:
    11. 	virtual void func1() { cout << "Base2::func1" << endl; }
    12. 	virtual void func2() { cout << "Base2::func2" << endl; }
    13. private:
    14. 	int b2;
    15. };
    16.  
    17. class Derive : public Base1, public Base2 {
    18. public:
    19. 	virtual void func1() { cout << "Derive::func1" << endl; }
    20. 	virtual void func3() { cout << "Derive::func3" << endl; }
    21. private:
    22. 	int d1;
    23. };
    24.  
    25.  
    26. typedef void(*V_FUNC)();
    27.  
    28. // 打印虚表
    29. void PrintVFTable(V_FUNC* a)
    30. {
    31. 	printf("vfptr:%p\n", a);
    32.  
    33. 	for (size_t i = 0; a[i] != nullptr; ++i)
    34. 	{
    35. 		printf("[%d]:%p->", i, a[i]);
    36. 		V_FUNC f = a[i];
    37. 		f();
    38. 	}
    39. }
    40.  
    41. int main()
    42. {
    43. 	Base1 b1;
    44. 	Base2 b2;
    45.  
    46. 	Derive d;
    47.  
    48. 	PrintVFTable((V_FUNC*)(*(int*)&d));
    49. 	PrintVFTable((V_FUNC*)(*(int*)((char*)&d + sizeof(Base1))));//转换成char*是为了偏移单位为1个字节
    50. }

     运行结果为：

    通过分析可以看到，多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中

    面试题：

    1

     运行结果是什么？

    1. class A
    2. {
    3. public:
    4. 	virtual void func(int val = 1){ std::cout << "A->" << val << std::endl; }
    5. 	virtual void test(){ func(); }
    6. };
    7.  
    8. class B : public A
    9. {
    10. public:
    11. 	void func(int val = 0){ std::cout << "B->" << val << std::endl; }
    12. };
    13.  
    14. int main(int argc, char* argv[])
    15. {
    16. 	B*p1 = new B;
    17. 	p1->test();
    18. 	return 0;
    19. }

    上面这段代码的运行结果是 B->1,你可能会问为什么不是B->0？首先应为B继承了A，所以调用test先跳到A里面的test函数，这里会发生一次切割，p1变成了A类型的指针，但是存的东西是不变的，还是B类对象的指针的地址，因此，test里面的func还是会调用B中的func函数，重点到了！可以看到B和A的func函数构成了重写，同时是A类型指针调用了基类的函数，这构成了多态。而多态是一种对重写函数的接口继承，多态是对函数的函数的实现进行重写，因此它的函数函数的接口还是virtual void func(int val = 1)，实现是按照{ std::cout << "B->" << val << std::endl; }实现，因此会打印出B->1。 

  • 相关阅读:
    造车先做三蹦子-之三:自制数据集(6x6数据集)230103
    [附源码]Python计算机毕业设计Django第三方游戏零售平台
    Node.js
    一个斜杠引发的CDN资源回源请求量飙升
    计算机网络的标准化工作与相关组织
    Android 11 新增系统属性 persist.sys.test
    形态学 - 击中-击不中变换
    LeetCode算法栈—验证图书取出顺序
    开源与闭源：数字化时代的辩论与未来走向
    Centos8上部署MySQL主从备份
  • 原文地址：https://blog.csdn.net/qq_52378490/article/details/127911226