• ＜多态＞——《C++高阶》

    目录

    1. 多态的概念

    1.1 概念

    2. 多态的定义及实现

    2.1多态的构成条件

             2.2 虚函数

    2.3虚函数的重写

    2.4 C++11 override 和 fifinal

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

    3. 抽象类

    3.1 概念

    3.2 接口继承和实现继承

    4.多态的原理

    4.1虚函数表

    4.2多态的原理

    4.3 动态绑定与静态绑定

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

    5.1 单继承中的虚函数表

     5.2 多继承中的虚函数表

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

    6. 继承和多态常见的面试问题 

    6.1 概念查考

    6.2 问答题

    后记：●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                           ——By 作者：新晓·故知

    1. 多态的概念

    1.1 概念

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

    2. 多态的定义及实现

    2.1多态的构成条件

    多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了
    Person。Person对象买票全价，Student对象买票半价。
    那么在继承中要构成多态还有两个条件：
    1. 必须通过基类的指针或者引用调用虚函数
    2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

    2.2 虚函数

    虚函数：即被virtual修饰的类成员函数称为虚函数 。 
    1. class Person 
    2. {
    3. public:
    4. 	virtual void BuyTicket() { cout << "买票-全价" << endl; }
    5. };

    2.3虚函数的重写

    虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。 
    1. class Person
    2. {
    3. public: 
    4. 	virtual void BuyTicket()
    5. 	{ 
    6. 		cout << "买票-全价" << endl;
    7. 	}
    8. }; 
    9. class Student : public Person 
    10. { 
    11. public:
    12. 	virtual void BuyTicket() { cout << "买票-半价" << endl; } 
    13. 	/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，
    14. 	虽然也可以构成重写(因 为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),
    15. 	但是该种写法不是很规范，不建议 这样使用*/ 
    16. 	/*void BuyTicket() { cout << "买票-半价" << endl; }*/ 
    17. }; 
    18. void Func(Person& p)
    19. {
    20. 	p.BuyTicket();
    21. }
    22. int main()
    23. {
    24. 	 Person ps;
    25. 	 Student st;
    26. 	 Func(ps);
    27. 	 Func(st);
    28. 	 return 0;
    29. }

    1. class Person
    2. {
    3. public:
    4. 	Person(const char* name)
    5. 		:_name(name)
    6. 	{}
    7. 	virtual void BuyTicket() {cout <<_name<<" " << "买票-全价" << endl; }
    8. protected:
    9. 	string _name;
    10. };
    11. class Student : public Person
    12. {
    13. public:
    14. 	Student(const char* name)
    15. 		:Person(name)
    16. 	{}
    17. 	virtual void BuyTicket() { cout<<_name <<" " << "买票-半价" << endl; }
    18. 	/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，
    19. 	虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),
    20. 	但是该种写法不是很规范，不建议 这样使用*/
    21. 	/*void BuyTicket() { cout << "买票-半价" << endl; }*/
    22. };
    23. class Soldier : public Person
    24. {
    25. public:
    26. 	Soldier(const char* name)
    27. 		:Person(name)
    28. 	{}
    29. 	virtual void BuyTicket() { cout <<_name<<" " << "优先买票-全价" << endl; }
    30. };
    31.  
    32. //void Pay(Person& p)
    33. //{
    34. //	p.BuyTicket();
    35. //}
    36. //父类的指针可以指向子类的对象
    37. void Pay(Person* p)
    38. {
    39. 	p->BuyTicket();
    40. 	delete p;
    41. }
    42. //多态两个要求：
    43. //1.子类虚函数重写的父类虚函数   重写要求：三同（函数名、参数、返回值相同）+虚函数
    44. //2.父类指针或者引用去调用虚函数
    45. int main()
    46. {
    47. 	int option;
    48. 	do
    49. 	{
    50. 		cout << "请选择身份：";
    51. 		cout << "0.退出 1.普通人 2.学生 3.军人" << endl;
    52. 		cin >> option;	
    53. 		cout << "请输入姓名：";
    54. 		string name;
    55. 		cin >> name;
    56. 		switch (option)
    57. 		{
    58. 		case 0:
    59. 			break;
    60. 		case 1:
    61. 			Pay(new Person(name.c_str()));
    62. 			break;
    63. 		case 2:
    64. 			Pay(new Student(name.c_str()));
    65. 			break;
    66. 		case 3:
    67. 			Pay(new Soldier(name.c_str()));
    68. 			break;
    69. 		default:
    70. 			cout << "输入身份错误，请重新输入！" << endl;
    71. 			break;
    72. 		}
    73. 	} while (option != 0);
    74.  
    75. 	return 0;
    76. }

    虚函数重写的两个例外：
    1. 协变(基类与派生类虚函数返回值类型不同)
    派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指
    针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。（了解） 
    1. class A {};
    2. class B : public A {};
    3. class Person 
    4. {
    5. public:
    6. 	virtual A* f() { return new A; }
    7. };
    8. class Student : public Person 
    9. {
    10. public:
    11. 	virtual B* f() { return new B; }
    12. };

    1. class A 
    2. {
    3. };
    4. class B : public A 
    5. {
    6. };
    7. //虚函数重写对返回值要求有一个例外：协变（要求是父子关系的指针和引用）
    8. class Person
    9. {
    10. public:
    11. 	virtual A* f() 
    12. 	{ 
    13. 		cout << "virtual A* Person::f()" << endl;
    14. 		return new A;
    15. 	}
    16. };
    17. class Student : public Person
    18. {
    19. public:
    20. 	virtual B* f()
    21. 	{ 
    22. 		cout << "virtual B* Student::f()" << endl;
    23. 		return new B;
    24. 	}
    25. 	//若子类虚函数没有写virtual，但子类的依旧是虚函数，因为先继承了父类函数接口声明
    26. };
    27.  
    28. int main()
    29. {
    30. 	Person p;
    31. 	Student s;
    32. 	Person* ptr = &p;
    33. 	ptr->f();
    34.  
    35. 	ptr = &s;
    36. 	ptr->f();
    37. 	return 0;
    38. }

     

    1. class A
    2. {
    3. };
    4. class B : public A
    5. {
    6. };
    7. //虚函数重写对返回值要求有一个例外：协变（要求是父子关系的指针和引用）
    8. class Person
    9. {
    10. public:
    11. 	virtual A* f()
    12. 	{
    13. 		cout << "virtual A* Person::f()" << endl;
    14. 		return new A;
    15. 	}
    16. 	//或引用
    17. 	/*virtual const A& f()    
    18. 	{
    19. 		cout << "virtual A* Person::f()" << endl;
    20. 		return   A();
    21. 	}*/
    22. };
    23. class Student : public Person
    24. {
    25. public:
    26. 	virtual B* f()  
    27. 	{
    28. 		cout << "virtual B* Student::f()" << endl;
    29. 		return new B;
    30. 	}
    31. 	//或引用
    32. 	/*virtual const B& f()
    33. 	{
    34. 		cout << "virtual B* Student::f()" << endl;
    35. 		return  B();
    36. 	}*/
    37. 	//若子类虚函数没有写virtual，但子类的依旧是虚函数，因为先继承了父类函数接口声明
    38. 	//而重写的是父类虚函数的实现
    39. 	//const B& f()  //virtual B& f()
    40. 	//{
    41. 	//	cout << "virtual B* Student::f()" << endl;
    42. 	//	return B();
    43. 	//}
    44. };
    45.  
    46. int main()
    47. {
    48. 	Person p;
    49. 	Student s;
    50. 	Person* ptr = &p;
    51. 	ptr->f();
    52.  
    53. 	ptr = &s;
    54. 	ptr->f();
    55. 	return 0;
    56. }

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

    理，编译后析构函数的名称统一处理成destructor。

     

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

     

    2.4 C++11 override 和 fifinal

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

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

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

    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虚函数表

    1. // 这里常考一道笔试题：sizeof(Base)是多少？
    2. class Base
    3. {
    4. public:
    5. 	virtual void Func1()
    6. 	{
    7. 		cout << "Func1()" << endl;
    8. 	}
    9. private:
    10. 	int _b = 1;
    11. };
    通过观察测试我们发现b对象是8bytes，除了_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. }

    1.  
    2. class Base
    3. {
    4. public:
    5. 	virtual void Func1()
    6. 	{
    7. 		cout << "Base::Func1()" << endl;
    8. 	}
    9. 	virtual void Func2()
    10. 	{
    11. 		cout << "Base::Func2()" << endl;
    12. 	}
    13. 	void Func3()
    14. 	{
    15. 		cout << "Base::Func3()" << endl;
    16. 	}
    17. private:
    18. 	int _b = 1;
    19. };
    20. class Derive : public Base
    21. {
    22. public:
    23. 	virtual void Func1()
    24. 	{
    25. 		cout << "Derive::Func1()" << endl;
    26. 	}
    27. private:
    28. 	int _d = 2;
    29. };
    30. int main()
    31. {
    32. 	Base b;
    33. 	Derive d;
    34. 	cout << sizeof(Base) << endl;
    35. 	cout << sizeof(Derive) << endl;
    36.  
    37. 	return 0;
    38. }

     

    通过观察和测试，我们发现了以下几点问题：
    1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。
    2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
    3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函
    数，所以不会放进虚表。
    4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
    5. 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
    6. 这里还有一个童鞋们很容易混淆的问题：虚函数存在哪的？虚表存在哪的？ 答：虚函数存在虚表，虚表存在对象中。注意上面的回答的错的。但是很多童鞋都是这样深以为然的。注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在代码段的，Linux g++下大家自己去验证？
    虚函数重写 ——语法层的概念——派生类对继承的基类虚函数实现了重写子类的虚表，拷贝父类虚表进行了修改。
    虚函数覆盖——原理层的概念——子类的虚表，拷贝父类虚表进行了修改，覆盖重写那个虚函数。

    反汇编： 

    总结：

    多态调用--运行时决议--运行时查虚函数表确定调用函数的地址 

    普通调用--编译时决议--编译时确定调用函数的地址

    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. 	void Func3()
    27. 	{
    28. 		cout << "Derive::Func3()" << endl;
    29. 	}
    30. private:
    31. 	int _d = 2;
    32. };
    33. int main()
    34. {
    35. 	Base b;
    36. 	Derive d;
    37. 	/*cout << sizeof(Base) << endl;
    38. 	cout << sizeof(Derive) << endl;*/
    39.  
    40. 	Base* p = &b;
    41. 	p->Func1();
    42. 	p->Func3();
    43.  
    44. 	p = &d;
    45. 	p->Func1();
    46. 	p->Func3();
    47.  
    48. 	return 0;
    49. }

    1. int main()
    2. {
    3. 	Base b;
    4. 	Derive d;
    5. 	/*cout << sizeof(Base) << endl;
    6. 	cout << sizeof(Derive) << endl;*/
    7.  
    8.     //指针
    9. 	/*Base* p = &b;
    10. 	p->Func1();
    11. 	p->Func3();
    13. 	p = &d;
    14. 	p->Func1();
    15. 	p->Func3();*/
    16.  
    17. 	引用
    18. 	//Base& r1 = b;
    19. 	//r1.Func1();
    20. 	//r1.Func3();
    21.  
    22. 	//Base& r2 = d;
    23. 	//r2.Func1();
    24. 	//r2.Func3();
    25.  
    26. 	//对象
    27. 	Base r1 = b;
    28. 	r1.Func1();
    29. 	r1.Func3();
    30.  
    31. 	Base r2 = d;
    32. 	r2.Func1();
    33. 	r2.Func3();
    34. 	return 0;
    35. }

     

    4.2多态的原理

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

    1. class Person 
    2. {
    3. public:
    4. 	virtual void BuyTicket() { cout << "买票-全价" << endl; }
    5. };
    6. class Student : public Person
    7. {
    8. public:
    9. 	virtual void BuyTicket() { cout << "买票-半价" << endl; }
    10. };
    11. void Func(Person& p)
    12. {
    13. 	p.BuyTicket();
    14. }
    15. int main()
    16. {
    17. 	Person Mike;
    18. 	Func(Mike);
    19. 	Student Johnson;
    20. 	Func(Johnson);
    21. 	return 0;
    22. }
    1. 观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。
    2. 观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中
    找到虚函数是Student::BuyTicket。
    3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
    4. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？
    5. 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。 
    1. void Func(Person* p) 
    2. {
    3. 	p->BuyTicket();
    4. }
    5. int main()
    6. {
    7. 	Person mike;
    8. 	Func(&mike);
    9. 	mike.BuyTicket();
    10.  
    11. 	return 0;
    12. }
    13. // 以下汇编代码中跟你这个问题不相关的都被去掉了
    14. void Func(Person* p) 
    15. {
    16. 	     ...
    17. 	    p->BuyTicket();
    18. 	    // p中存的是mike对象的指针，将p移动到eax中
    19. 	    001940DE  mov         eax, dword ptr[p]
    20. 		// [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx
    21. 		001940E1  mov         edx, dword ptr[eax]
    22. 		// [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
    23. 		00B823EE  mov         eax, dword ptr[edx]
    24. 		// call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来
    25. 		以后到对象的中取找的。
    26. 		001940EA  call        eax
    27. 		00头1940EC  cmp         esi, esp
    28. }
    29. int main()
    30. {
    31. 	...
    32. 		// 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调
    33. 		//用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址
    34. 		mike.BuyTicket();
    35. 	    00195182  lea         ecx, [mike]
    36. 		00195185  call        Person::BuyTicket(01914F6h)
    37. 		...
    38. }

    4.3 动态绑定与静态绑定

    1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
    2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
    3. 本小节之前(5.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. };
    观察下图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。那么我们如何查看d的虚表呢？下面我们使用代码打印出虚表中的函数。 
    1. typedef void(*VFPTR) ();
    2. void PrintVTable(VFPTR vTable[])
    3. {
    4. 	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
    5. 	cout << " 虚表地址>" << vTable << endl;
    6. 	for (int i = 0; vTable[i] != nullptr; ++i)
    7. 	{
    8. 		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
    9. 		VFPTR f = vTable[i];
    10. 		f();
    11. 	}
    12. 	cout << endl;
    13. }
    14. int main()
    15. {
    16. 	Base b;
    17. 	Derive d;
    18. 	// 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数
    19. 	//指针的指针数组，这个数组最后面放了一个nullptr
    20. 	// 1.先取b的地址，强转成一个int*的指针
    21. 	// 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
    22. 	// 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
    23. 	// 4.虚表指针传递给PrintVTable进行打印虚表
    24. 	// 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最
    25. 	//后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的 - 生成 - 清理解决方案，再
    26. 	//编译就好了。
    27. 	VFPTR * vTableb = (VFPTR*)(*(int*)&b);
    28. 	PrintVTable(vTableb);
    29. 	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
    30. 	PrintVTable(vTabled);
    31. 	return 0;
    32. }

     

     5.2 多继承中的虚函数表 

    1. class Base1
    2. {
    3. public:
    4. 	virtual void func1() { cout << "Base1::func1" << endl; }
    5. 	virtual void func2() { cout << "Base1::func2" << endl; }
    6. private:
    7. 	int b1;
    8. };
    9. class Base2
    10. {
    11. public:
    12. 	virtual void func1() { cout << "Base2::func1" << endl; }
    13. 	virtual void func2() { cout << "Base2::func2" << endl; }
    14. private:int b2;
    15. };
    16. class Derive : public Base1, public Base2
    17. {
    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. typedef void(*VFPTR) ();
    25. void PrintVTable(VFPTR vTable[])
    26. {
    27. 	cout << " 虚表地址>" << vTable << endl;
    28. 	for (int i = 0; vTable[i] != nullptr; ++i)
    29. 	{
    30. 		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
    31. 		VFPTR f = vTable[i];
    32. 		f();
    33. 	}
    34. 	cout << endl;
    35. }
    36. int main()
    37. {
    38. 	Derive d;
    39. 	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
    40. 	PrintVTable(vTableb1);
    41. 	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
    42. 	PrintVTable(vTableb2);
    43. 	return 0;
    44. }
    观察下图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中 
    1.  
    2. class Base
    3. {
    4. public:
    5. 	virtual void Func1()
    6. 	{
    7. 		cout << "Base::Func1()" << endl;
    8. 	}
    9. 	virtual void Func2()
    10. 	{
    11. 		cout << "Base::Func2()" << endl;
    12. 	}
    13. 	void Func3()
    14. 	{
    15. 		cout << "Base::Func3()" << endl;
    16. 	}
    17. private:
    18. 	int _b = 1;
    19. };
    20. class Derive : public Base
    21. {
    22. public:
    23. 	virtual void Func1()
    24. 	{
    25. 		cout << "Derive::Func1()" << endl;
    26. 	}
    27. 	void Func3()
    28. 	{
    29. 		cout << "Derive::Func3()" << endl;
    30. 	}
    31. 	virtual void Func4()
    32. 	{
    33. 		cout << "Derive::Func4()" << endl;
    34. 	}
    35. private:
    36. 	int _d = 2;
    37. };
    38. //派生类Derive增加了自己的虚函数，
    39. //通过打印内存，确认Func4写进了虚函数表
    40. //typedef void(*)() V_FUNC;  //不支持
    41. typedef void(*V_FUNC)();
    42. //打印虚表
    43. void PrintVFTable(V_FUNC* a)  //或void PrintVFTable(V_FUNC a[])
    44. {
    45. 	printf("&vfptr:%p\n", a);
    46. 	//VS环境下的虚表都以空指针做结尾，Linux环境下的g++需指定确定的个数，例：i<3
    47. 	for (size_t i = 0; a[i] != nullptr; ++i)
    48. 	{
    49. 		printf("[%d]:%p->", i, a[i]);
    50. 		V_FUNC f = a[i];
    51. 		f();
    52. 	}
    53. }
    54. int main()
    55. {
    56. 	/*Base b;
    57. 	PrintVFTable((V_FUNC*)*((int*)&b));*/
    58.  
    59. 	Derive d;
    60. 	printf("&Derive::Func1真正地址：%p\n", &Derive::Func1); //真正的地址
    61.  
    62. 	PrintVFTable((V_FUNC*)(*((int*)&d)));  //取对象前4字节的虚表指针，并打印
    63. 	虚表存在那个区域？   在常量区（代码段）
    64. 	验证：打印不同区的变量地址，比对分析
    65. 	//int n = 0;          //局部变量，存放在栈区
    66. 	//static int m = 1;   //静态变量，存放在静态区（数据段）
    67. 	//const char* str = "hello,world";  //字符串常量，存放在常量区（代码段）
    68. 	//int* q = new int[10];   //new动态开辟，存放在堆区
    69. 	//printf("n存放区(栈区)：\t\t\t\t %p\n", &n);
    70. 	//printf("m存放区（静态区（数据段））：   \t %p\n", &m);
    71. 	//printf("字符串常量存放区（常量区（代码段））：\t %p\n", str);
    72. 	//printf("new动态开辟的对象存放区（堆区）：\t %p\n", q);
    73. 	//printf("虚表存放区：\t\t\t\t %p\n", (*((int*)&d)));
    74. 	//printf("函数地址存放区：\t\t\t %p\n", &Derive::Func1);
    75. 	//printf("函数地址存放区：\t\t\t %p\n", &Derive::Func2);
    76. 	//printf("函数地址存放区：\t\t\t %p\n", &Derive::Func3);
    77. 	//printf("函数地址存放区：\t\t\t %p\n", &Derive::Func4);
    78.  
    79. 	/*Base* ptr1 = &d;
    80. 	Base* ptr2 = &d;
    81. 	Derive ptr3 = &d;
    82. 	cout << ptr1 << endl;
    83. 	cout << ptr2 << endl;
    84. 	cout << ptr3 << endl;*/
    85.  
    86. 	/*Derive d;
    87. 	Base1* ptr1 = &d;
    88. 	Base2* ptr2 = &d;
    90. 	ptr1->func1();
    91. 	ptr2->func1();*/
    92. 	//结论：Derive对象Base2虚表中func1时，是Base2指针ptr2指针去调用
    93. 	//但是这时ptr2发生切片指针偏移，需要修正，中途就需要修正存储this指针ecx的值
    94.  
    95. 	return 0;
    96. }

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

    实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的 模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看 了，一般我们也不需要研究清楚，因为实际中很少用。如果好奇心比较强的同学，可以去看下面 的两篇链接文章。
    1. C++ 虚函数表解析
    2. C++ 对象的内存布局

    6. 继承和多态常见的面试问题 

    6.1 概念查考

    1. 下面哪种面向对象的方法可以让你变得富有( )
    A: 继承 B: 封装 C: 多态 D: 抽象
    2. ( )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，而对方法的调用则可以关联于具体的对象。
    A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定
    3. 面向对象设计中的继承和组合，下面说法错误的是？（）
    A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复
    用，也称为白盒复用
    B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动
    态复用，也称为黑盒复用
    C：优先使用继承，而不是组合，是面向对象设计的第二原则
    D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封
    装性的表现
    4. 以下关于纯虚函数的说法,正确的是( )
    A：声明纯虚函数的类不能实例化对象 B：声明纯虚函数的类是虚基类
    C：子类必须实现基类的纯虚函数 D：纯虚函数必须是空函数
    5. 关于虚函数的描述正确的是( )
    A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型 B：内联函数不能是虚函数
    C：派生类必须重新定义基类的虚函数 D：虚函数可以是一个static型的函数
    6. 关于虚表说法正确的是（ ）
    A：一个类只能有一张虚表
    B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表
    C：虚表是在运行期间动态生成的
    D：一个类的不同对象共享该类的虚表
    7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（ ）
    A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址
    B：A类对象和B类对象前4个字节存储的都是虚基表的地址
    C：A类对象和B类对象前4个字节存储的虚表地址相同
    D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表
    8. 下面程序输出结果是什么? （） 
    1. #include
    2. using namespace std;
    3. class A 
    4. {
    5. public:
    6. 	A(char* s) { cout << s << endl; }
    7. 	~A() {}
    8. };
    9. class B :virtual public A 
    10. {
    11. public:
    12. 	B(char* s1, char* s2) :A(s1) { cout << s2 << endl; }
    13. };
    14. class C :virtual public A 
    15. {
    16. public:
    17. 	C(char* s1, char* s2) :A(s1) { cout << s2 << endl; }
    18. };
    19. class D :public B, public C 
    20. {
    21. public:
    22. 	D(char* s1, char* s2, char* s3, char* s4) :B(s1, s2), C(s1, s3), A(s1)
    23. 	{
    24. 		cout << s4 << endl;
    25. 	}
    26. };
    27. int main() 
    28. {
    29. 	D* p = new D("class A", "class B", "class C", "class D");
    30. 	delete p;
    31. 	return 0;
    32. }
    A：class A class B class C class D B：class D class B class C class A
    C：class D class C class B class A D：class A class C class B class D

     9. 多继承中指针偏移问题？下面说法正确的是( )

    1. class Base1 
    2. {
    3. 	public:  int _b1; 
    4. };
    5. class Base2
    6. {
    7. 	public:  int _b2; 
    8. };
    9. class Derive : public Base1, public Base2 
    10. { 
    11. 	public: int _d; 
    12. };
    13. int main() 
    14. {
    15.     Derive d;
    16.     Base1* p1 = &d;
    17. 	Base2* p2 = &d;
    18. 	Derive* p3 = &d;
    19. 	return 0;	
    20. }
    A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3
    10. 以下程序输出结果是什么（） 
    1. class A
    2. {
    3. public:
    4. 	virtual void func(int val = 1) 
    5. 	{ 
    6. 		std::cout << "A->" << val << std::endl;
    7. 	}
    8. 	virtual void test() { func(); }
    9. };
    10.  
    11. class B : public A
    12. {
    13. public:
    14. 	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
    15. };
    16.  
    17. int main(int argc, char* argv[])
    18. {
    19. 	B* p = new B;
    20. 	p->test();
    21. 	return 0;
    22. }
    A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

    参考答案：
      1. A   2. D   3. C   4. A   5. B
      6. D   7. D   8. A   9. C   10. B

    6.2 问答题

    1. 什么是多态？答：参考本节课件内容
    2. 什么是重载、重写(覆盖)、重定义(隐藏)？答：参考本节课件内容
    3. 多态的实现原理？答：参考本节课件内容
    4. inline函数可以是虚函数吗？答：可以，不过编译器就忽略inline属性，这个函数就不再是
    inline，因为虚函数要放到虚表中去。
    5. 静态成员可以是虚函数吗？答：不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
    6. 构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
    7. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以，并且最好把基类的析构函数定义成虚函数。参考本节课件内容
    8. 对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。
    9. 虚函数表是在什么阶段生成的，存在哪的？答：虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。
    10. C++菱形继承的问题？虚继承的原理？答：参考继承课件。注意这里不要把虚函数表和虚基表搞混了。
    11. 什么是抽象类？抽象类的作用？答：参考（3.抽象类）。抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。

    后记：
    ●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                           ——By 作者：新晓·故知

     

  • 相关阅读:
    labview与stm32通信
    jumpserver迁移后windowserver资产无法登陆问题排查
    微带线的ABCD矩阵的推导、转换与级联-Matlab计算实例
    【吞噬星空】又被骂，罗峰杀人目无法纪，但官方留后手，增加审判戏份
    java_ 多线程知识笔记(一)
    WebRTC QoS方法之Pacer实现
    iMazing2023永久免费版苹果iOS设备管理软件
    神经网络分类任务
    【如何学习Python自动化测试】—— 鼠标键盘操作
    Django配置连接池：使用django-db-connection-pool配置连接池
  • 原文地址：https://blog.csdn.net/m0_57859086/article/details/126246172