• C++ 多态

    目录

    一、多态的定义和实现

    1.1 多态的构成条件：

    1.2 虚函数的重写（覆盖）：

    1.3 多态的两个特殊点：

    1.4 析构函数的重写：

    1.5 override和final

    1.6 重载，重定义（隐藏），重写（覆盖）的区别

    二、抽象类

    2.1 纯虚函数

    2.2 接口继承和实现继承

    三、多态的原理

    3.1 虚函数表

    3.2 验证派生类自己新增的虚函数会不会存储在派生类虚表中：

    3.3 多态的原理

    3.4 动态绑定与静态绑定

    四、多继承中的虚函数表

    4.1 普通多继承下的虚函数表：

    4.2 菱形继承下的多态

    五、多态相关题

    一、多态的定义和实现

    1.1 多态的构成条件：

    构成多态需要两个条件：

    1. 必须通过基类的指针或者引用调用虚函数

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

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

    1.2 虚函数的重写（覆盖）：

    派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了父类的虚函数。 （其实就是和基类的虚函数声明完全相同，函数体不同，类似于重新定义函数的行为）

    1.3 多态的两个特殊点：

    1. 派生类中对基类虚函数进行重写时，可以省略virtual关键字，此时该函数仍然为虚函数且构成重写。建议加上virtual声明，更规范。（因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性）

    2. 协变：派生类对基类虚函数进行重写时，要求函数名，参数列表，返回值都相同。一个例外是返回值类型可以不同，基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

    1.4 析构函数的重写：

    回顾继承：

    1. 在继承体系中，派生类的析构函数会自动调用基类析构函数去清理基类部分数据成员

    2. 并且编译器会将继承体系中的析构函数函数名处理为destructor，所以若不将基类析构函数定义为虚函数，默认为隐藏关系！

    那么，如果执行下面代码时，析构函数就必须重写！

    1. class Base
    2. {
    3. public:
    4. 	Base()
    5. 		:p(new int[10])
    6. 	{
    7. 	}
    8. 	virtual ~Base()
    9. 	{
    10. 		cout << "~Base()" << endl;
    11. 		delete p;
    12. 	}
    13. protected:
    14. 	int* p;
    15. };
    16.  
    17. class Derived : public Base
    18. {
    19. public:
    20. 	Derived()  // 自动调用基类的默认构造函数
    21. 		:p2(new double[10])
    22. 	{
    23. 	}
    24. 	virtual ~Derived()
    25. 	{
    26. 		cout << "~Derived()" << endl;
    27. 		delete p2;
    28. 	}
    29. protected:
    30. 	double* p2;
    31. };
    32.  
    33. int main()
    34. {
    35. 	Base* p = new Base;
    36. 	delete p;
    37. 	Base* p2 = new Derived;
    38. 	delete p2;
    39. 	return 0;
    40. }

    delete p2时，delete语句会执行 p2->destructor();   operator delete(ptr2); 调用p2所指向的析构函数，此时若不将析构函数定义为虚函数，则不会发生重写，而是隐藏。则第二个delete时，事实上，Derived类中会有两个析构函数，一个是基类的，一个是自己的。p2类型为Base*，且没有发生多态，只能调用基类的析构函数。

    因此，诸如上方示例，建议将继承体系中的析构函数定义为虚函数，这样子类就可以对父类析构函数进行重写。

    可以理解，编译后析构函数函数名被编译器处理为destructor()，也是为了便于设为虚函数，发生多态和动态绑定。这样delete基类指针时，才能调用正确的析构函数，即指向父类调用父类的析构函数，指向子类调用子类的析构函数。

    1.5 override和final

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

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

    1.6 重载，重定义（隐藏），重写（覆盖）的区别

    重载：两个函数在同一定义域，函数名相同，参数列表不同。

    重定义（隐藏）：两个函数分别在基类和派生类的作用域中，函数名相同。

    重写（覆盖）：两个函数分别在基类和派生类的作用域中，函数名，参数，返回值相同（协变除外）

    事实上，基类和派生类中，两个函数如果函数名相同，若没有构成重写，就是重定义（隐藏）

    二、抽象类

    2.1 纯虚函数

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

    1. class Base
    2. {
    3. public:
    4.     virtual void Drive() = 0;
    5. };

    2.2 接口继承和实现继承

    普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实 现，故，实际上调用基类的普通函数时，函数隐含的this指针类型为 Base* const。

    虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。（因为如果基类定义虚函数，派生类不重写，则Base*->func()调用时 仍然为运行时绑定，只是因为没有重写，执行的一定是基类的虚函数，还降低了效率） 

    三、多态的原理

    3.1 虚函数表

    1. class Base
    2. {
    3. public:
    4. 	Base()
    5. 		:p(new int[10])
    6. 	{
    7. 	}
    8. 	virtual ~Base()
    9. 	{
    10. 		delete p;
    11. 	}
    12. 	virtual void Func1()
    13. 	{
    14. 		cout << "virtual void Base::Func1()" << endl;
    15. 	}
    16. 	virtual void Func2()
    17. 	{
    18. 		cout << "virtual void Base::Func2()" << endl;
    19. 	}
    20.     void Func3()
    21.     {
    22.         cout << "void Base::func3()" << endl;
    23.     }
    24. protected:
    25. 	int* p;
    26. };
    27.  
    28. class Derived : public Base
    29. {
    30. public:
    31. 	Derived()  // 自动调用基类的默认构造函数
    32. 		:p2(new double[10])
    33. 	{
    34. 	}
    35. 	virtual ~Derived()
    36. 	{
    37. 		delete p2;
    38. 	}
    39. 	virtual void Func1() // 重写基类Func1
    40. 	{
    41. 		cout << "virtual void Derived::Func1()" << endl;
    42. 	}
    43. protected:
    44. 	double* p2;
    45. };
    46.  
    47. void test1()
    48. {
    49. 	Base b;
    50. 	Derived d;
    51. }

    1. 每一个含有虚函数的类的实例化对象中都有一个指针成员，称为虚函数表指针（虚表指针），即上图中的_vfptr(virtual function ptr)，这个指针指向一个虚函数表（简称虚表，一种函数指针数组），这个虚函数表中会存储这个类定义的所有虚函数的地址。

    2. 因为基类定义了虚函数，所以每一个虚函数的地址会存储在基类的虚表指针指向的虚表中，派生类继承基类，这个虚表指针和虚表作为基类的数据成员也被继承了下来，派生类内重写了的虚函数的地址会覆盖基类的虚函数的地址。故上图中，基类和派生类的虚表中 析构函数的地址不同，Func1的地址不同，而Func2的地址相同。

    3. 虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数地址的覆盖。重写是语法的叫法，覆盖是原理层的叫法。 （派生类虚表中Func1和析构函数覆盖基类的Func1和析构函数）

    4. 基类的非虚函数Func3不会放进虚表中。

    5. 容易混淆的问题：虚函数存在哪的？虚表存在哪的？ 虚函数和普通函数一样，存储在代码段。类对象中存储的是虚表指针，而不是虚表。虚表中存储的是虚函数的地址，而不是虚函数。虚表事实上也是存储在代码段的（只读的，vs下）

    6. 派生类虚表生成大致过程：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生 类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

    3.2 验证派生类自己新增的虚函数会不会存储在派生类虚表中：

    1. class Base
    2. {
    3. public:
    4. 	Base()
    5. 		:p(new int[10])
    6. 	{
    7. 	}
    8. 	//virtual ~Base()
    9. 	//{
    10. 	//	delete p;
    11. 	//}
    12. 	virtual void Func1()
    13. 	{
    14. 		cout << "virtual void Base::Func1()" << endl;
    15. 	}
    16. 	virtual void Func2()
    17. 	{
    18. 		cout << "virtual void Base::Func2()" << endl;
    19. 	}
    20. protected:
    21. 	int* p;
    22. };
    23.  
    24. class Derived : public Base
    25. {
    26. public:
    27. 	Derived()  // 自动调用基类的默认构造函数
    28. 		:p2(new double[10])
    29. 	{
    30. 	}
    31. 	//~Derived()
    32. 	//{
    33. 	//	delete p2;
    34. 	//}
    35. 	virtual void Func1() // 重写基类Func1
    36. 	{
    37. 		cout << "virtual void Derived::Func1()" << endl;
    38. 	}
    39. 	virtual void new_add()
    40. 	{
    41. 		cout << "virtual void Derived::new_add()" << endl;
    42. 	}
    43. protected:
    44. 	double* p2;
    45. };
    46.  
    47. typedef void(*VFPtr)();
    48.  
    49. void print_virtual_function_table(VFPtr* VFTable)  // 函数指针数组
    50. {
    51. 	for (int i = 0; VFTable[i]; ++i)
    52. 	{
    53. 		printf("VFTable[%d] : %p\n", i, VFTable[i]);
    54. 		VFTable[i]();
    55. 	}
    56. }
    57. void test1()
    58. {
    59. 	Base b;
    60. 	Derived d;
    61. 	print_virtual_function_table((VFPtr*)*(int*)&d);
    62. }

    事实证明，派生类自己新增的虚函数是会按照声明顺序添加到自己的虚函数表的后端的。只是VS下的监控窗口隐藏了。 

    3.3 多态的原理

    有了上面虚函数表和虚函数指针的基础，再来理解多态的原理。

    如上，符合多态的条件：基类指针调用重写好的虚函数。

    1. 多态调用：程序（进程）运行过程中，会去指针指向的对象的虚表指针指向的虚表中找到函数的地址，进行调用。所以，p2指向的是基类，调用基类的虚函数，指向派生类，调用派生类的虚函数。

     2. 不满足多态的普通函数调用，编译链接时已经确定函数的地址，运行时直接调用。

    感想：这里其实还存在切片的现象，比如基类指针指向派生类对象，可以理解为指针指向的是派生类中基类的这一部分， 虚表指针也属于这一部分。因此，当使用基类指针或者引用（引用同理）调用虚函数时，会去指向对象（基类对象or派生类对象）的虚表指针指向的虚表中找函数地址。发生多态现象，称为动态绑定（运行时绑定）

    3.4 动态绑定与静态绑定

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

    2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体 行为，调用具体的函数，也称为动态多态。

    四、多继承中的虚函数表

    4.1 普通多继承下的虚函数表：

    1. class Base1
    2. {
    3. public:
    4. 	virtual void func1() {
    5. 		printf("Base1::func\n");
    6. 	}
    7. 	virtual void func2() {
    8. 		cout << "Base1::func2" << endl;
    9. 	}
    10. private:
    11. 	int b1;
    12. };
    13.  
    14. class Base2 {
    15. public:
    16. 	virtual void func1() { cout << "Base2::func1" << endl; }
    17. 	virtual void func2() { cout << "Base2::func2" << endl; }
    18. private: 
    19. 	int b2;
    20. };
    21.  
    22. class Derive : public Base1, public Base2 {
    23. public:
    24. 	virtual void func1() { cout << "Derive::func1" << endl; }
    25. 	virtual void func3() { cout << "Derive::func3" << endl; }
    26. private:
    27. 	int d1;
    28. };
    29.  
    30. typedef void(*VFPtr)();
    31.  
    32. void print_virtual_function_table(VFPtr* VFTable)  // 函数指针数组
    33. {
    34. 	for (int i = 0; VFTable[i]; ++i)
    35. 	{
    36. 		printf("VFTable[%d] : %p\n", i, VFTable[i]);
    37. 		VFTable[i]();
    38. 	}
    39. }
    40.  
    41. int main()
    42. {
    43. 	Base1 b;
    44. 	Derive d;
    45. 	print_virtual_function_table((VFPtr*)*(int*)&d);
    46. 	cout << endl;
    47. 	print_virtual_function_table((VFPtr*)*(int*)((char*)&d + sizeof(Base1)));
    48. 	return 0;
    49. }

    1. 派生类有两个基类，每个基类都有定义虚函数，则每个基类都有虚函数表指针，派生类继承就会有两个虚函数表指针，func1进行了重写，因此两个虚表中func1的地址都进行了覆盖。func2没有覆盖。而派生类自己新增的虚函数会存储在第一个继承基类部分的虚函数表中

    注：这里存在很多编译器的行为，比如这里的地址事实上并不是函数的真实地址（函数的第一条指令的地址），而是某跳转指令的地址，跳转指令会跳转至函数真正的执行语句。但是我们依然理解为虚表中存储的是虚函数的地址！

    第二个点：上图中打印的派生类重写了的func1函数，函数地址不同，这里是因为Base2* 去调用这个func1时，要进行一些额外操作：Base2*指向的是基类Base2部分的虚表指针处，调用func1需要事先将此指针减一些偏移量，使其指向派生类对象的开端，即派生类对象的地址，因此函数地址不同。下图所示，执行eax - 8

    下图为派生类对象直接调用func1和Base1*调用func1（指向派生类），Base2*调用func1（指向派生类）的汇编代码。

    4.2 菱形继承下的多态

    1. class A
    2. {
    3. public:
    4. 	virtual void func1()
    5. 	{
    6. 		cout << "A::func1()" << endl;
    7. 	}
    8. public:
    9. 	int _a;
    10. };
    11.  
    12.  //class B : public A
    13. class B : virtual public A
    14. {
    15. public:
    16. 	virtual void func1()
    17. 	{
    18. 		cout << "B::func1()" << endl;
    19. 	}
    20.  
    21. 	virtual void func2()
    22. 	{
    23. 		cout << "B::func2()" << endl;
    24. 	}
    25. public:
    26. 	int _b;
    27. };
    28.  
    29.  //class C : public A
    30. class C : virtual public A
    31. {
    32. public:
    33. 	virtual void func1()
    34. 	{
    35. 		cout << "C::func1()" << endl;
    36. 	}
    37.  
    38. 	virtual void func2()
    39. 	{
    40. 		cout << "C::func2()" << endl;
    41. 	}
    42. public:
    43. 	int _c;
    44. };
    45.  
    46. class D : public B, public C
    47. {
    48. public:
    49. 	virtual void func1()
    50. 	{
    51. 		cout << "D::func1()" << endl;
    52. 	}
    53. public:
    54. 	int _d;
    55. };
    56.  
    57. int main()
    58. {
    59. 	D d;
    60. 	cout << sizeof(d) << endl;
    61. 	d.B::_a = 1;
    62. 	d.C::_a = 2;
    63. 	d._b = 3;
    64. 	d._c = 4;
    65. 	d._d = 5;
    66. 	//print_virtual_function_table((VFPtr*)*(int*)&d);
    67. 	//cout << endl;
    68. 	//print_virtual_function_table((VFPtr*)*(int*)((char*)&d + sizeof(B)));
    69. 	return 0;
    70. }

     

     D中有BC基类数据，还有_d，BC内都是除了自己的_b _c 还有虚表指针（因为虚函数），虚基表指针（因为虚拟继承）。虚基表中存储着到本类的虚表指针的偏移量，以及基类A部分数据的偏移量。基类A中有一个虚表指针（图中的0x00349b90)和自己的_a

    五、多态相关题

    1.    class A
    2.    {
    3.    public:
    4.        virtual void func(int val = 1){ std::cout<<"A->"<< val <
    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 <
    12.    };
    13.    
    14.    int main(int argc ,char* argv[])
    15.    {
    16.        B*p = new B;
    17.        p->test();
    18.        return 0;
    19.    }

    B* p 指向派生类对象。test是一个虚函数，是属于基类的，此时隐含的this指针为A* const this，将p赋值过去（注意这里调用test是一个常规的函数调用），使得this指针为基类类型，指向派生类对象，调用func，发生动态绑定和多态现象。此时调用的是派生类的虚表中存储的func，但是因为虚函数的继承是一种接口继承，目的是为了重写函数体，所以，此时函数的参数列表为int val = 1，因此结果为B->1。

  • 相关阅读:
    SpringMVC的执行流程
    Ruby语言基础知识
    MySQL练习题15道
    Python常见问题
    运算符【详细】
    ACM-概率题(其一)
    RestTemplate Message Convert 详解
    java版工程管理系统Spring Cloud+Spring Boot+Mybatis实现工程管理系统源码
    Qt+ECharts开发笔记（四）：ECharts的饼图介绍、基础使用和Qt封装百分比图Demo
    数字信号处理8：利用Python进行数字信号处理基础
  • 原文地址：https://blog.csdn.net/i777777777777777/article/details/127578570