• C++ 多态

    目录

    前言 多态的概念

    一、多态的定义及实现

    1.1 多态的构成条件

    ​编辑

    1.2 虚函数与虚函数重写

    extra 虚函数重写的两个例外       

    ⭐协变

    ⭐析构函数的重写

    1.3 C++11 override 和 final

    extra 重载、覆盖(重写)、隐藏(重定义)      

    二、抽象类

    2.1 抽象类的概念

    2.2 接口继承和实现继承

    三、多态的原理

    3.1 虚函数表        

    3.2 多态的原理

    3.3 动态绑定与静态绑定        

    四、单继承和多继承关系中的虚函数表 

    4.1 单继承中的虚函数表

    4.2 多继承中的虚函数表        

    4.3. 菱形继承、菱形虚拟继承        

    总结与回顾

    前言 多态的概念

    多态的概念：字面意思即多种状态，具体点就是当不同的对象去完成某个行为时产生出的状态不同

            例如：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人
    买票时是优先买票，甚至可以买到普通人买不到的预留票；最近为了争夺在线支付市场，支付宝、拼多多等软件年底经常会做诱人的扫红包给奖励金的活动。那么大家想想为什么有人扫的红包是面额较大的8块、10块...，而有人扫的红包都是1毛，1分...。其实这背后也是一个多态行为。支付宝首先会分析你的账户数据，比如你是新用户、比如你没有经常支付宝支付等等，那么你需要被鼓励使用支付宝，那么就你扫码金额 =random()%99；比如你经常使用支付宝支付或者支付宝账户中常年没钱，那么就不需要太鼓励你去使用支付宝，那么就你扫码金额 = random()%1；总结一下：同样是扫码动作，不同的用户扫得到的不一样的红包，这也是一种多态行为。

    一、多态的定义及实现

    1.1 多态的构成条件

    多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了
    Person。Person对象买票全价，Student对象买票半价。
    那么在继承中要构成多态还有两个条件：

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

    普通调用：取决于调用这个函数的对象的类型

    多态调用：取决于调用这个函数的指针或引用指向的对象的类型。指向父类调用父类的函数，指向子类调用子类的函数

    1.2 虚函数与虚函数重写

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

    1. class Person 
    2. {
    3. public:
    4.     virtual void BuyTicket() { cout << "买票-全价" << endl;}
    5. };
    6.  
    7. tips: virtual只能用来修饰成员函数

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

    1. class Person {
    2. public:
    3.     virtual void BuyTicket() { cout << "买票-全价" << endl; }
    4. };
    5.  
    6. class Student : public Person {
    7. public:
    8.     virtual void BuyTicket() { cout << "买票-半价" << endl; }
    9. //  注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写
    10. //(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性)，但是该种写法不是很规范，
    11. //不建议这样使用
    12.     /*void BuyTicket() { cout << "买票-半价" << endl; }*/
    13. };

    extra 虚函数重写的两个例外       

    ⭐协变

    (基类与派生类虚函数返回值类型不同)派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变

    示例1：

    1. class A{};
    2. class B : public A {};
    3.  
    4. class Person {
    5. public:
    6.     virtual A* f() {return new A;}
    7. };
    8.  
    9. class Student : public Person {
    10. public:
    11.     virtual B* f() {return new B;}
    12. };

    示例2：        

    ⭐析构函数的重写

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

            delete 根据类型调用析构的方式可能出现问题，稍不注意可能会没有正确调用析构，导致内存泄漏，只需把析构函数定义为虚函数，就能构成多态

            

    1. class Person {
    2. public:
    3.     virtual ~Person() {cout << "~Person()" << endl;}
    4. };
    5.  
    6. class Student : public Person {
    7. public:
    8.     virtual ~Student() { cout << "~Student()" << endl; }
    9. };
    10.  
    11. 注意：只有派生类Student的析构函数重写了基类Person的析构函数，下面的delete对象
    12. 调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数
    13. void test()
    14. {
    15.     /*
    16.     Person p;
    17.     Student s;
    18.     // 运行结果
    19.     ~Student()
    20.     ~Person()    // 先子后父
    21.     ~Person()    // 先构造的后析构
    22.     */
    23.  
    24.     Person* p = new Person;
    25.     // p->destrutor() + operator delete(p)
    26.     delete p;
    27.  
    28.     p = new Student;
    29.     // p->destrutor() + operator delete(p)
    30. 	delete p;
    31. }

    派生类的成员函数可以省略virtual (反正都要继承父类的成员函数，连virtual也一起继承下来)

    train：如果你感觉自己行了，不妨看看下面这道选择题        

    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()
    15. {
    16.     B*p = new B;
    17.     p->test();
    18.     return 0;
    19. }
    20.  
    21. A: A->0    B: B->1     C: A->1     D: B->0 
    22. E: 编译出错     F: 以上都不正确
    23.  
    24. //  B->1 普通调用p->test()，A中的test调用B的func()的函数体
    25. //  构成多态的三同：函数名、返回类型、参数的类型
    26. //  注意，虚函数func被重写了，但是继承了A中func函数的接口声明，重写的是函数实现

    1.3 C++11 override 和 final

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

    1. class Car
    2. {
    3. public:
    4.     virtual void Drive() final {}
    5. };
    6. class Benz :public Car
    7. {
    8. public:
    9.     virtual void Drive() {cout << "Benz-舒适" << endl;}
    10. };

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

    1. class Car{
    2. public:
    3.     virtual void Drive(){}
    4. };
    5. class Benz :public Car {
    6. public:
    7.     virtual void Drive() override {cout << "Benz-舒适" << endl;}
    8. };

    extra 重载、覆盖(重写)、隐藏(重定义)      

            

            

    二、抽象类

    2.1 抽象类的概念

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

    1. class Car
    2. {
    3. public:
    4.     virtual void Drive() = 0;
    5. };
    6.  
    7. class Benz :public Car
    8. {
    9. public:
    10.     virtual void Drive()
    11.     {
    12.         cout << "Benz-舒适" << endl;
    13.     }
    14. };
    15.  
    16. class BMW :public Car
    17. {
    18. public:
    19.     virtual void Drive()
    20.     {
    21.         cout << "BMW-操控" << endl;
    22.     }
    23. };
    24.  
    25. void test()
    26. {
    27.     // 抽象类常用于定义指针
    28.     Car* pBenz = new Benz;
    29.     pBenz->Drive();
    30.     Car* pBMW = new BMW;
    31.     pBMW->Drive();
    32. }

    2.2 接口继承和实现继承

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

    三、多态的原理

    3.1 虚函数表        

    1. class Base
    2. {
    3. public:
    4.     virtual void Func1()
    5.     {
    6.         cout << "Func1()" << endl;
    7.     }
    8. private:
    9.     int _b = 1;
    10.     char _ch;
    11. };
    12.  
    13. 32位平台下sizeof(Base)是多少？    // 12

            通过观察测试我们发现Base对象是12bytes，除了_b成员，_ch成员，还有一个指针_vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关，当前测试平台为VS2022)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function，t代表table)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表

    那么派生类中这个表放了些什么呢？我们接着往下分析
    再看一组测试代码的内存和监视窗口

            

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

    1. 派生类对象s中也有一个虚表指针，s对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。
    2. 基类p对象和派生类s对象虚表是不一样的，这里我们发现BuyTicket完成了重写，所以s的虚表中存的是重写的Student::BuyTicket，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法层的叫法，覆盖是原理层的叫法。
    3. 另外func继承下来后是虚函数，所以放进了虚表，但是派生类中并没有重写func函数，我们可以在内存窗口看到s的虚表中func函数的地址和基类保持一致
    4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr，便于访问
    5. 派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中；b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数；c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
    6. 虚函数存在哪的？虚表存在哪的？虚函数存在虚表里，虚表存在对象中。上面的回答是错误的，注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。

    我们接下来看一下，虚函数表又是存在哪的：

    1. class Base {
    2. public:
    3. 	virtual void func1() { cout << "Base::func1" << endl; }
    4. 	virtual void func2() { cout << "Base::func2" << endl; }
    5. private:
    6. 	int a;
    7. };
    8.  
    9. void func()
    10. {
    11. 	cout << "void func()" << endl;
    12. }
    13.  
    14. int main()
    15. {
    16. 	Base b1;
    17. 	Base b2;
    18.  
    19. 	static int a = 0;
    20. 	int b = 0;
    21. 	int* p1 = new int;
    22. 	const char* p2 = "hello world";
    23. 	printf("静态区:%p\n", &a);
    24. 	printf("栈:%p\n", &b);
    25. 	printf("堆:%p\n", p1);
    26. 	printf("代码段:%p\n", p2);
    27.     // 32位平台下，虚表的地址在对象的地址中的前4位
    28.     // 类型转换的原则是相似类型之间才能够转换，指针可以在任意类型之间转换
    29. 	printf("虚表:%p\n", *((int*)&b1));
    30. 	printf("虚函数地址:%p\n", &Base::func1);
    31. 	printf("普通函数地址:%p\n", func);
    32.  
    33. 	return 0;
    34. }
    35.  
    36.  
    37. // VS2022 运行结果
    38.  
    39. 静态区:002DD414
    40. 栈:00FDFC94
    41. 堆:0147EE78
    42. 代码段:002DAB64
    43. 虚表:002DAB34
    44. 虚函数地址:002D15A5
    45. 普通函数地址:002D15A0

            

    3.2 多态的原理

    上面分析了这个半天了，那么多态的原理到底是什么？还记得这里Func函数传Person调用的
    Person::BuyTicket，传Student调用的是Student::BuyTicket吗？

    1. 观察图中的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket；观察图中的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
    2. 构成多态有两个条件，一个是虚函数覆盖，一个是对象的基类指针或引用调用虚函数。为什么需要是基类指针或引用，基类对象不可以吗？把子类对象交给父类的指针或引用，实际上就是让父类的指针或引用指向子类对象中切割出来的父类的那一部分，而把子类对象交给父类对象实际上就是一个拷贝的过程，这个过程并不会把子类对象虚表中的指针也拷贝到父类对象的虚表中。为什么不拷贝子类对象的虚函数表指针呢？假设父类对象 = 子类对象会拷贝虚函数表指针，还能够保证多态调用时，基类指针或引用指向父类，调用的还是父类的虚函数吗？显然不能，父类对象如果被子类对象赋值过，父类对象里面的虚表就不再是父类虚表了，而是子类虚表了
    3. 再通过下面的汇编代码分析，可以看出来满足多态的函数调用，不是在编译时确定的，是运行时到对象的虚表中去寻找被调函数的地址，确定地址后再调用。不满足多态的函数调用在编译链接时就确定被调函数的地址
    1. void Func(Person* p)
    2. {
    3.     p->BuyTicket();
    4. }
    5.  
    6. int main()
    7. {
    8.     Person mike;
    9.     Func(&mike);
    10.     mike.BuyTicket();
    11.  
    12.     return 0;
    13. }
    14.  
    15. // 以下汇编代码中跟你这个问题不相关的都被去掉了
    16. void Func(Person* p)
    17. {
    18.     ...
    19.     p->BuyTicket();
    20. // p中存的是mike对象的指针，将p移动到eax中
    21.     001940DE mov eax,dword ptr [p]
    22. // [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx
    23.     001940E1 mov edx,dword ptr [eax]
    24. // [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
    25.     00B823EE mov eax,dword ptr [edx]
    26. /* call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，
    27. 是运行起来以后到对象的中取找的。 */
    28.     001940EA call eax
    29.     001940EC cmp esi,esp
    30. }
    31.  
    32. int main()
    33. {
    34.     ...
    35. /* 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是
    36. 普通函数的调用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址 */
    37.     mike.BuyTicket();
    38.     00195182 lea ecx,[mike]
    39.     00195185 call Person::BuyTicket (01914F6h)
    40.     ...
    41. }

    如果子类不重写虚函数，父类和子类对象的虚表是否一样？    

    我们可以看到，父类和子类的虚表是不一样的，尽管它们里面的内容是相同的。但是同类的不同对象的虚表是一样的  

    3.3 动态绑定与静态绑定        

    1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
    2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
    3. 本文中买票的汇编代码很好的解释了什么是静态(编译器)绑定和动态(运行时)绑定

            

    四、单继承和多继承关系中的虚函数表 

    需要注意的是在单继承和多继承关系中，下面我们去关注的是派生类对象的虚表模型，因为基类的虚表模型前面我们已经看过了，没什么需要特别研究的

    4.1 单继承中的虚函数表

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

            观察下图中的监视窗口中我们发现看不见func3和func4。监视窗口是被微软的工程师处理过的，故意隐藏了这两个函数，可能是为了优化用户某些方面的体验吧。那么我们如何查看d的虚表呢？我们可以通过内存窗口进一步查看，也可以使用代码打印出虚表中的函数
            通过内存窗口，我们好像也不能够看清一切的真相，接下来我们可以打印出虚表中的函数来进一步观察

    1. class Base {
    2. public:
    3. 	virtual void func1() { cout << "Base::func1" << endl; }
    4. 	virtual void func2() { cout << "Base::func2" << endl; }
    5. private:
    6. 	int a;
    7. };
    8.  
    9. class Derive :public Base {
    10. public:
    11. 	virtual void func1() { cout << "Derive::func1" << endl; }
    12. 	virtual void func3() { cout << "Derive::func3" << endl; }
    13. 	virtual void func4() { cout << "Derive::func4" << endl; }
    14. 	void func5() { cout << "Derive::func5" << endl; }
    15. private:
    16. 	int b;
    17. };
    18.  
    19. class X :public Derive {
    20. public:
    21. 	virtual void func3() { cout << "X::func3" << endl; }
    22. };
    23.  
    24. // 打印虚表
    25. typedef void (*VFUNC)();
    26. //void PrintVFT(VFUNC a[])
    27. void PrintVFT(VFUNC* a)
    28. {
    29. 	for (size_t i = 0; a[i] != 0; i++)
    30. 	{
    31. 		printf("[%d]:%p->", i, a[i]);
    32.         // 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
    33. 		VFUNC f = a[i];
    34. 		f();    // (*f)();
    35. 	}
    36. 	printf("\n");
    37. }
    38.  
    39. int main()
    40. {
    41. 	void (*f1)();
    42. 	VFUNC f2;
    43.  
    44. 	Base b;
    45. 	PrintVFT((VFUNC*)(*((int*)&b)));    // 32位平台
    46.     
    47.     // 注意：类型之间转换是有原则的，只有相似的类型之间才能转换
    48.     // 例如，int类型可以转换为double类型，但是不能转换为VFUNC类型
    49.     // 而指针之间是可以随意转换的，因为它们本质上就是一个地址，可以看作是int类型
    50.  
    51. 	Derive d;
    52. 	PrintVFT((VFUNC*)(*((int*)&d)));
    53.  
    54. 	X x;
    55. 	PrintVFT((VFUNC*)(*((int*)&x)));
    56.  
    57.     // 64位平台指针占8个字节，需要进行相应的调整
    58. 	// PrintVFT((VFUNC*)&b);
    59. 	// PrintVFT((VFUNC*)(*((long long*)&d)));    
    60.  
    61. 	return 0;
    62. }
    63.  
    64. // VS2022平台下运行结果
    65.  
    66. [0]:00C412B7->Base::func1
    67. [1]:00C4111D->Base::func2
    68.  
    69. [0]:00C41249->Derive::func1
    70. [1]:00C4111D->Base::func2
    71. [2]:00C41235->Derive::func3
    72. [3]:00C41172->Derive::func4
    73.  
    74. [0]:00C41249->Derive::func1
    75. [1]:00C4111D->Base::func2
    76. [2]:00C410A0->X::func3
    77. [3]:00C41172->Derive::func4

    思路：取出b、d对象的头4bytes（32位平台），就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr

    1. 先取b的地址，强转成一个int*的指针
    2. 再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
    3. 再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
    4. 虚表指针传递给PrintVTable进行打印虚表
    5. 需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再编译就好了

            

    4.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. };
    24.  
    25. int main()
    26. {
    27. 	Derive d;
    28. 	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
    29. 	PrintVTable(vTableb1);
    30.  
    31. 	// VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
    32.     Base2* ptr = &d;    // 利用切片可以写出可读性更好的代码
    33. 	PrintVTable(vTableb2);
    34. 	return 0;
    35. }
    36.  
    37. 子类继承了几个有虚表的父类，它就有几个虚表，VS下子类的虚表放在最前面

    32位平台下运行结果：

    我们再看一段代码的运行结果以及汇编代码分析（了解一下，看不懂也无所谓

    4.3. 菱形继承、菱形虚拟继承        

    *实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们不必深入研究了，实际中的运用也很少用，有兴趣也可阅读下面两篇博文
    1. C++ 虚函数表解析

    C++ 虚函数表解析 | 酷 壳 - CoolShellicon-default.png?t=N7T8https://coolshell.cn/articles/12165.html
    2. C++ 对象的内存布局

    C++ 对象的内存布局 | 酷 壳 - CoolShellicon-default.png?t=N7T8https://coolshell.cn/articles/12176.html        

    总结与回顾

    部分常见问题答疑

    1. 什么是多态？
    2. ——静态的多态：函数重载；动态的多态：父类的指针/引用调用虚函数，虚函数完成重写
    3.  
    4. 什么是重载、重写(覆盖)、重定义(隐藏)？
    5. ——见博客上文
    6.  
    7. 多态的实现原理？
    8. ——见博客上文
    9.  
    10. inline函数可以是虚函数吗？
    11. ——可以，普通调用，inline会起作用；多态调用，inline不起作用
    12.  
    13. 静态成员可以是虚函数吗？
    14. ——不能，编译报错，因为静态成员函数没有this指针，
    15. 使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
    16.  
    17. 构造函数可以是虚函数吗？
    18. ——不能，编译报错，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
    19.  
    20. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？
    21. ——可以，并且最好把基类的析构函数定义成虚函数
    22. 场景:  父类指针 = new 子类对象;    delete 父类指针;
    23. 该场景下只有析构函数构成重写，delete父类指针时构成多态，才能正确调用子类对象的析构函数
    24.  
    25. 对象访问普通函数快还是虚函数更快？
    26. ——如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，
    27. 因为构成多态，运行时调用虚函数需要到虚函数表中去查找。
    28.  
    29. 虚函数表是在什么阶段生成的，存在哪的？
    30. ———虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。
    31.  
    32. C++菱形继承的问题？虚继承的原理？
    33. ——见博客上文
    34.  
    35. 什么是抽象类？抽象类的作用？
    36. ——抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。
    37.

  • 相关阅读:
    VMware Tanzu 和 Spring 更新
    114. 二叉树展开为链表
    【kali-信息收集】（1.6）服务的指纹识别：Nmap、Amap
    报告分享|2022年深度学习平台发展报告PPT
    【智能优化算法-灰狼算法】基于狩猎 (DLH) 搜索策略的灰狼算法求解单目标优化问题附matlab代码
    【面试题精讲】构造方法有哪些特点？是否可被 override?
    【线性代数】行列式和矩阵
    pod(七)：静态pod
    pytorch3d安装遇到的一些坑和解决过程
    kotlin的集合使用maxBy函数报NoSuchElementException
  • 原文地址：https://blog.csdn.net/weixin_72501602/article/details/134019205