【C++从青铜到王者】第十八篇:C++之多态

朱雀 2022-08-31 04:45 172阅读 0赞

![在这里插入图片描述][b91c761485dd4fc4943e80c5f3d67261.png_pic_center]

# 系列文章目录 #

--------------------

### 文章目录 ###

*  系列文章目录
 *  前言
 *  一、多态的概念
 *   *   *  1.多态的概念
 *  二、多态的定义及实现
 *   *   *  1.多态的构成条件
         *  2.虚函数的认识
         *  3.虚函数的重写
         *   *  1.虚函数重写的两个例外之协变
             *  2.虚函数重写的两个例外之析构函数的重写
         *  4.C++11 override 和 final
         *   *  1.final:修饰虚函数，表示该虚函数不能再被重写
             *  2.override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错
         *  5. 重载、覆盖(重写)、隐藏(重定义)的对比
 *  三、抽象类的认识
 *   *   *  1.抽象类的概念
         *  2.接口继承和实现继承
 *  四、多态的原理
 *   *   *  1.虚函数表
         *  2.多态的原理
         *  3.动态绑定与静态绑定
 *  五、单继承和多继承关系的虚函数表
 *   *   *  1.单继承中的虚函数表
         *  2.多继承中的虚函数表
         *  3.菱形继承、菱形虚拟继承
 *  六、继承和多态常见的面试问题
 *   *   *  1.概念查考
         *  2.问答题
 *  总结

--------------------

# 前言 #

**需要声明的，本节内容中的代码及解释都是在vs2013下的x86程序中，涉及的指针都是4bytes。如果要其他平台下，部分代码需要改动。比如：如果是x64程序，则需要考虑指针是8bytes问题等等。**

--------------------

![在这里插入图片描述][576c38b0c6804261a2e40d10c505ce67.png_pic_left]

# 一、多态的概念 #

### 1.多态的概念 ###

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

举个栗子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70]  
再举个栗子： 最近为了争夺在线支付市场，支付宝年底经常会做诱人的扫红包-支付-给奖励金的活动。那么大家想想为什么有人扫的红包又大又新鲜8块、10块…，而有人扫的红包都是1毛，5毛…。其实这背后也是一个多态行为。支付宝首先会分析你的账户数据，比如你是新用户、比如你没有经常支付宝支付等等，那么你需要被鼓励使用支付宝，那么就你扫码金额 = random()%99；比如你经常使用支付宝支付或者支付宝账户中常年没钱，那么就不需要太鼓励你去使用支付宝，那么就你扫码金额 = random()%1；总结一下：同样是扫码动作，不同的用户扫得到的不一样的红包，这也是一种多态行为。ps：支付宝红包问题纯属瞎编，大家仅供娱乐。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 1]

# 二、多态的定义及实现 #

### 1.多态的构成条件 ###

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

*  **那么在继承中要构成多态还有两个条件：**
 *  **必须通过基类的指针或者引用调用虚函数。**
 *  **被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 2]

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    class Person
    { 
    public:
    	virtual void BuyTicket()
    	{ 
    		cout << "买票-全价" << endl;
    	}
    };
    class Student :public Person
    { 
    	virtual void BuyTicket()  //派生类的virtual关键字也可以不用写也构成重写
    	{ 
    		cout << "买票-半价" << endl;
    	}
    };
    void Func1(Person& p)
    { 
    	p.BuyTicket();
    }
    void Func2(Person* p)
    { 
    	p->BuyTicket();
    }
    int main()
    { 
    	Person p;
    	Student s;
    
    	//传对象
    	Func1(p);
    	Func1(s);
    
    	//传对象的地址
    	Func2(&p); 
    	Func2(&s);
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 3]

### 2.虚函数的认识 ###

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

class Person
    { 
    public:
    	virtual void BuyTicket()
    	{ 
    		cout << "买票-全价" << endl;
    	}
    };

### 3.虚函数的重写 ###

**虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。** **注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用。**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 4]

#### 1.虚函数重写的两个例外之协变 ####

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

**返回值类型对象的指针:**

class Person
    { 
    public:
    	virtual Person* BuyTicket()
    	{ 
    		cout << "买票-全价" << endl;
    		return 0;
    	}
    };
    class Student :public Person
    { 
    	virtual Student* BuyTicket()  //派生类的virtual关键字也可以不用写也构成重写
    	{ 
    		cout << "买票-半价" << endl;
    		return 0;
    	}
    };
    void Func1(Person& p)
    { 
    	p.BuyTicket();
    }
    void Func2(Person* p)
    { 
    	p->BuyTicket();
    }
    int main()
    { 
    	Person p;
    	Student s;
    
    	//传对象的地址
    	Func2(&p);
    	Func2(&s);
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 5]  
**返回值类型为对象的引用:**

class Person
    { 
    public:
    	virtual Person& BuyTicket()
    	{ 
    		cout << "买票-全价" << endl;
    		return *this;
    	}
    };
    class Student :public Person
    { 
    	virtual Student& BuyTicket()  //派生类的virtual关键字也可以不用写也构成重写
    	{ 
    		cout << "买票-半价" << endl;
    		return *this;
    	}
    };
    void Func1(Person& p)
    { 
    	p.BuyTicket();
    }
    void Func2(Person* p)
    { 
    	p->BuyTicket();
    }
    int main()
    { 
    	Person p;
    	Student s;
    
    	//传对象
    	Func1(p);
    	Func1(s);
    
    	//传对象的地址
    	Func2(&p);
    	Func2(&s);
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 6]

#### 2.虚函数重写的两个例外之析构函数的重写 ####

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

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    
    class Person
    { 
    public:
    	virtual ~Person()
    	{ 
    		cout << "~Person()" << endl;
    	}
    };
    class Student :public Person
    { 
    public:
    	virtual ~Student()   //不加virtual也构成重写
    	{ 
    		cout << "~Student()" << endl;
    	}
    };
    // 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
    int main()
    { 
    	Person* p1 = new Person;
    	delete p1;
    
    	Person* p2 = new Student;
    	delete p2;
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 7]

### 4.C++11 override 和 final ###

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

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

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    class Car
    { 
    public:
    	virtual void Drive() final
    	{ }
    };
    class Benz :public Car
    { 
    	virtual void Drive()
    	{ 
    		cout << "Benz-舒服" << endl;
    	}
    };
    int main()
    { 
    	Car c;
    	Benz b;
    	c.Drive();
    	b.Drive();
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 8]

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

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    class Car
    { 
    public:
    	virtual void Drive()
    	{ }
    };
    class Benz :public Car
    { 
    public:
    	virtual void Dirve() override
    	{ 
    		cout << "Benz-舒服" << endl;
    	}
    };
    int main()
    { 
    	Car c;
    	Benz b;
    	c.Drive();
    	b.Drive();
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 9]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 10]

# 三、抽象类的认识 #

### 1.抽象类的概念 ###

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

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    class Car
    { 
    public:
    	virtual void Drive() = 0;
    };
    class Benz :public Car
    { 
    public:
    	virtual void Drive()
    	{ 
    		cout << "Benz-舒服" << endl;
    	}
    };
    class BMW:public Car
    { 
    public:
    	virtual void Drive()
    	{ 
    		cout << "BMW-操作" << endl;
    	}
    };
    int main()
    { 
    	Car* p = new Benz;
    	p->Drive();
    
    	Car* b = new BMW;
    	b->Drive();
    
    	Car c;
    
    	Benz b;
    
    	BMW bb;
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 11]

### 2.接口继承和实现继承 ###

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

# 四、多态的原理 #

### 1.虚函数表 ###

**这里常考一道笔试题：sizeof(Base)是多少？**

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    class Base
    { 
    public:
    	virtual void Func1()
    	{ 
    		cout << "Func1()" << endl;
    	}
    private:
    
    	int _b = 1;
    };
    int main()
    { 
    	Base b;
    	cout << sizeof(Base) << endl;
    	return 0;
    }

**在win32的平台下：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 12]  
**在x64平台下：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 13]  
**通过观察测试我们发现b对象是8bytes，除了\_b成员，还多一个\_\_vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表，。那么派生类中这个表放了些什么呢？我们接着往下分析:**

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    class Base
    { 
    public:
    	virtual void Func1()
    	{ 
    		cout << "Func1()" << endl;
    	}
    	virtual void Func2()
    	{ 
    		cout << "Func2()" << endl;
    	}
    	void Func3()
    	{ 
    		cout << "Func3()" << endl;
    	}
    private:
    	int _b = 1;
    };
    class Driver :public Base
    { 
    public:
    	virtual void Func1()
    	{ 
    		cout << "Func1()" << endl;
    	}
    private:
    	int _b = 2;
    };
    int main()
    { 
    	Base b;
    	Driver d;
    	cout << sizeof(b) << endl;
    	cout << sizeof(d) << endl;
    	return 0;
    }

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

int main()
    { 
    	Base b;
    	Driver d;
    	cout << sizeof(b) << endl;
    	cout << sizeof(d) << endl;
    
    	printf("vftptr虚表地址:%p\n", *(int*)&b);
    	//printf("vftptr虚表地址:%p\n",(int)b);直接转语法不接受,这里使用指针转，在解引用
    
    	int i = 0;
    	int* p1 = &i;
    	int* p2 = new int;
    	char* p3 = "bit";
    	printf("栈变量:%p\n", p1);
    	printf("堆变量:%p\n", p2);
    	printf("代码段常量%p\n", p3);
    	printf("虚函数地址:%p\n", &Base::Func1);
    	printf("普通函数地址:%p\n", &Base::Func3);
    
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 15]

### 2.多态的原理 ###

**上面分析了这个半天了那么多态的原理到底是什么？还记得这里Func函数传Person调用的Person::BuyTicket，传Student调用的Student::BuyTicket。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 2]

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    class Person
    { 
    public:
    	virtual void BuyTicket()
    	{ 
    		cout << "买票-全价" << endl;
    	}
    };
    class Student :public Person
    { 
    public:
    	virtual void BuyTicket()
    	{ 
    		cout << "买票-半价" << endl;
    	}
    };
    void Func(Person& p)
    { 
    	p.BuyTicket();
    }
    int main()
    { 
    	Person Mike;
    	Func(Mike);
    
    	Student Johnson;
    	Func(Johnson);
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 16]

*  **观察下图的绿色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket 。**
 *  **观察下图的黄色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。**
 *  **这样就实现出了不同对象去完成同一行为时，展现出不同的形态。**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 17]
 *  **反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？**
 *  **再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。**

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    class Person
    { 
    public:
    	virtual void BuyTicket()
    	{ 
    		cout << "买票-全价" << endl;
    	}
    };
    class Student :public Person
    { 
    public:
    	virtual void BuyTicket()
    	{ 
    		cout << "买票-半价" << endl;
    	}
    };
    void Func(Person& p)
    { 
    	p.BuyTicket();
    }
    int main()
    { 
    	Person Mike;
    	Func(Mike);
    	Student Johnson;
    	Func(Johnson);
    
    	Mike.BuyTicket();
    	return 0;
    }

*  满足多态的情况：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 18]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 19]
 *  不满足多态的情况：
 *  首先BuyTicket虽然是虚函数，但是Mike是对象，不满足多态的条件，所以这里是普通函数的调用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址  
    ![在这里插入图片描述][742a6363e582455dad3d2b5b949a860e.png]

### 3.动态绑定与静态绑定 ###

*  **静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载。**
 *  **动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。**
 *  **买票的汇编代码很好的解释了什么是静态(编译器)绑定和动态(运行时)绑定。**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 20]

# 五、单继承和多继承关系的虚函数表 #

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

### 1.单继承中的虚函数表 ###

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

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    class Base
    { 
    public:
    	virtual void func1()
    	{ 
    		cout << "Base::func1()" << endl;
    	}
    	virtual void func2()
    	{ 
    		cout << "Base::func2()" << endl;
    	}
    private:
    	int _a;
    
    };
    class Drive :public Base
    { 
    public:
    	virtual void func1()
    	{ 
    		cout << "Drive::func1()" << endl;
    	}
    	virtual void func3()
    	{ 
    		cout << "Drive::func3()" << endl;
    	}
    	virtual void func4()
    	{ 
    		cout << "Drive::func4()" << endl;
    	}
    private:
    	int _b;
    };
    typedef void(*VFPTR) ();
    void PrintVTable(VFPTR vTable[])
    { 
    	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
    	cout << "虚表地址>" << vTable << endl;
    	for (int i = 0; vTable[i] != nullptr; ++i)
    	{ 
    		printf("第%d个虚函数地址 :0X%x,->", i, vTable[i]);
    		VFPTR f = vTable[i];
    		f();
    	}
    	cout << endl;
    }
    int main()
    { 
    	Base b;
    	Drive d;
    	// 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数指针的
    	// 1.先取b的地址，强转成一个int*的指针
    	// 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
    	// 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
    	// 4.虚表指针传递给PrintVTable进行打印虚表
    	// 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有
    	//放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的 - 生成 - 清理解决方案，再编译就好了。
    	VFPTR* vTableb = (VFPTR*)(*(int*)&b);
    	PrintVTable(vTableb);
    	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
    	PrintVTable(vTabled);
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 22]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 23]

### 2.多继承中的虚函数表 ###

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    class Base1 
    { 
    public:
    	virtual void func1() 
    	{  
    		cout << "Base1::func1" << endl; 
    	}
    	virtual void func2() 
    	{ 
    		cout << "Base1::func2" << endl; 
    	}
    private:
    	int b1;
    };
    class Base2 
    { 
    public:
    	virtual void func1() 
    	{ 
    		cout << "Base2::func1" << endl; 
    	}
    	virtual void func2() 
    	{  
    		cout << "Base2::func2" << endl; 
    	}
    private:
    	int b2;
    };
    class Derive : public Base1, public Base2 
    { 
    public:
    	virtual void func1() 
    	{ 
    		cout << "Derive::func1" << endl; 
    	}
    	virtual void func3() 
    	{  
    		cout << "Derive::func3" << endl; 
    	}
    private:
    	int d1;
    };
    typedef void(*VFPTR) ();
    void PrintVTable(VFPTR vTable[])
    { 
    	cout << "虚表地址>" << vTable << endl;
    	for (int i = 0; vTable[i] != nullptr; ++i)
    	{ 
    		printf("第%d个虚函数地址 :0X%x,->", i, vTable[i]);
    		VFPTR f = vTable[i];
    		f();
    	}
    	cout << endl;
    }
    int main()
    { 
    	Derive d;
    	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
    	PrintVTable(vTableb1);
    	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
    	PrintVTable(vTableb2);
    	return 0;
    }

**观察下图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 24]

### 3.菱形继承、菱形虚拟继承 ###

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

# 六、继承和多态常见的面试问题 #

### 1.概念查考 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 25]

### 2.问答题 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 26]

--------------------

# 总结 #

以上就是今天要讲的内容，本文介绍了C++三大特性多态的使用，而多态提供了大量能使我们快速便捷地处理数据的函数和方法，我们务必掌握。另外如果上述有任何问题，请懂哥指教，不过没关系，主要是自己能坚持，更希望有一起学习的同学可以帮我指正，但是如果可以请温柔一点跟我讲，爱与和平是永远的主题，爱各位了。

![在这里插入图片描述][01e01782ab594fe58c236db35e54c49f.png_pic_center]

[b91c761485dd4fc4943e80c5f3d67261.png_pic_center]: /images/20220829/8bc58b7a477549eabb0de78d53ff8169.png
[576c38b0c6804261a2e40d10c505ce67.png_pic_left]: /images/20220829/b697cb6f5ffa458cb441c23fe61f7ec3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70]: /images/20220829/432ffd6e80ae47959aa55c10008f8064.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 1]: /images/20220829/dbc272a973a648fa97cf6dc5eb9041be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 2]: /images/20220829/7e7b3c9236a34c9487620a5644a753e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 3]: /images/20220829/1dab61792e8f4498b983c3788590679f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 4]: /images/20220829/a33297554a19444aad893def2daa0bc4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 5]: /images/20220829/d01a1b99780641da8d88d4a2ee64ec68.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 6]: /images/20220829/0b4e7af2868c49799b89f52f28573797.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 7]: /images/20220829/760cb1296fd4437396ac3c08696b0d19.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 8]: /images/20220829/7c9ee53d0b9d44a3811819f2c1260a32.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 9]: /images/20220829/d8d4ea7f30f2446ca3dcc02f4b436004.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 10]: /images/20220829/757fb5c4a207408f850aaf16af4af10a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 11]: /images/20220829/d0cba37e6c2e4ed7bc5eb72c8c81b330.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 12]: /images/20220829/f56f1511bc8a4037b017ad6186803a42.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 13]: /images/20220829/231abc6d79534ddf86fa4773b5dd4f55.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 14]: /images/20220829/0366f0f9158b4910aab998d8e31deedc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 15]: /images/20220829/dee59c689f664e43bb9d66cf63cdd84b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 16]: /images/20220829/0d06d1f4eb1444bbb02d5fa1113bf7d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 17]: /images/20220829/2dc32e22033e4f51ad302dc12c5ad709.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 18]: /images/20220829/87ceb0b0105b42aab160f1d74974b310.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 19]: /images/20220829/e343ca1efd16439db71a1745bc32fd50.png
[742a6363e582455dad3d2b5b949a860e.png]: /images/20220829/51e762f9992a4725bc6bc06e1151e423.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 20]: /images/20220829/71eb7da687a64a8b990850fdaca2a9f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 21]: /images/20220829/231e373d0a824fc69eb7be7f414dd01a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 22]: /images/20220829/f7d68cccf04743e78dadea05714893ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 23]: /images/20220829/7808b0dd74974e6b967ce880a1a68f01.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 24]: /images/20220829/2a7baba0b7c841ceb292b59b3e7e0448.png
[C]: https://coolshell.cn/articles/12165.html
[C 1]: https://coolshell.cn/articles/12176.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 25]: /images/20220829/f8cd5f43c04b466eaa4b6f3563750028.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 26]: /images/20220829/e512a0f001db4d84ba7abee26f9f82b5.png
[01e01782ab594fe58c236db35e54c49f.png_pic_center]: /images/20220829/36227f6dd34840c18dce1a2d24edeee7.png