【C++】多态

深藏阁楼爱情的钟 2024-03-17 09:47 56阅读 0赞

#### 文章目录 ####

*  多态
 *   *  1. 多态的概念
     *  2. 多态的定义及实现
     *   *  2.1 多态的构成条件
         *  2.2 虚函数
         *  2.3 虚函数的重写
         *  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 多继承中的虚函数表
     *  6 继承和多态常见面试题
     *   *  6.1 概念
         *  6.2 问答题

## 多态 ##

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

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

就比如：买票的时候，当普通人买票的时候，是全价买票；学生买票时，是半价买票；军人买票时，就是优先购买

### 2. 多态的定义及实现 ###

#### 2.1 多态的构成条件 ####

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

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

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

![1c44674b34bd27a6928e24386c184189.png][]

#### 2.2 虚函数 ####

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

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

#### 2.3 虚函数的重写 ####

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

class Person
    {
    public:
    	virtual void buyTicket()
    	{
    		cout << "买票-全价" << endl;
    	}
    };
    
    class Student : public Person
    {
    public:
    	virtual void buyTicket()
    	{
    		cout << "买票-半价" << endl;
    	}
    };
    
    void Func(Person& person)
    {
    	person.buyTicket();
    }
    int main()
    {
    	Person person;
    	Func(person);
    	Student student;
    	Func(student);
    }

![cd056ad17a599d9aaa1a3f776289eaa0.png][]

虚函数重写的另外两个例子：

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

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

![image-20230417212726524][]

1.  析构函数的重写（基类与派生类析构函数名字不同）

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

class Person
    {
    public:
    	virtual ~Person()
    	{
    		cout << "~Person()" << endl;
    	}
    };
    class Student : public Person
    {
    	virtual ~Student()
    	{
    		cout << "~Student()" << endl;
    	}
    };
    int main()
    {
    	Person* p1 = new Person;
    	Person* p2 = new Student;
    	delete p1;
    	delete p2;
    	return 0;
    }

只有派生类Student的析构重写了Person的析构函数，下面的delete函数调用析构函数才能构成多态，才能保证p1, p2指向的对象正确的调用析构函数

#### 2.4 C++11中的 override和final ####

从上面的内容可以看出来，C++对函数重写的要求比较严格，但是有些情况，可能会导致函数名字母词序写反而无法构成重写，而在这种情况下是编译器是无法爆出错误的，只有在程序运行时没有得到预期地结果才调试出来。因此C++11提供了`override和final`两个关键字，可以帮助我们检测是否重写

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

![image-20230417214207708][]

1.  override：检查派生类虚函数是否重写了某个基类的虚函数，如果没有重写就报错

![image-20230417214527153][]

#### 2.5 重载、覆盖（重写）隐藏（重定义）的对比 ####

![image-20230417214616161][]

### 3. 抽象类 ###

#### 3.1 概念 ####

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

class Car
    {
    public:
    	virtual void Drive() = 0;
    };
    class Benz : public Car
    {
    public:
    	virtual void Drive()
    	{
    		cout << "Benz()" << endl;
    	}
    };
    class BMW : public Car
    {
    	virtual void Drive()
    	{
    		cout << "BMW" << endl;
    	}
    };
    void Test()
    {
    	Car* pBenz = new Benz;
    	pBenz->Drive();
    	Car* pBMW = new BMW;
    	pBMW->Drive();
    }

#### 3.2 接口继承和实现继承 ####

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现

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

### 4. 多态的原理 ###

#### 4.1 虚表函数 ####

class Base
    {
        
    public:
    	virtual void Func1()
    	{
        
    		cout << "Func1()" << endl;
    	}
    private:
    	int _b = 1;
    };

通过观察测试我们发现b对象好像是8字节，除了\_b成员，还多了一个vfptr 放在对象的前面（有些平台可能放在对象的最后面，这个跟平台有关），对象中的这个指针我们叫做虚函数表指针。一个虚函数的类当中至少都有一个虚函数表指针，因为虚函数的地址要放到虚函数表中，虚函数表也简称为虚表

![image-20230418205156368][]

// 针对上面的代码我们做出以下改造
    // 1. 增加一个派生类继承Base
    // 2. Drive中重写Func1
    // 3. Base再增加一个虚函数Fun2和一个普通的函数
    class Base
    {
    public:
    	virtual void Func1()
    	{
    		cout << "Base::Func1()" << endl;
    	}
    	virtual void Func2()
    	{
    		cout << "Base::Func2()" << endl;
    	}
    	void Func3()
    	{
    		cout << "Base::Func3" << endl;
    	}
    private:
    	int _b = 1;
    };
    class Derive : public Base
    {
    public:
    	virtual void Func1()
    	{
    		cout << "Driver::Func1()" << endl;
    	}
    private:
    	int _d = 2;
    };
    int main()
    {
    	Base b;
    	Derive d;
    	return 0;
    }

通过观察和测试我们发现如下几个问题：

1.  派生类对象d中也有一个虚表函数，d对象有两部分组成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员
2.  基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法
3.  Fun2继承下来是虚函数，所以放进了虚表，Func3也继承下来，但是不是虚函数，所以不会放进虚表
4.  虚函数表本质是一个存虚函数指针的指针数组，一般情况下这个数组最后放了个nullptr

总结一下派生类的虚表生成：

1.  先将基类的虚表内容拷贝一份到派生类虚表当中
2.  如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚函数表中基类的虚函数
3.  派生类自己声明的虚函数按其在派生中的声明次序增加到派生类虚表的最后

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gTUkGa1p-1685708985097)(null)\]

#### 4.2 多态的原理 ####

![image-20230418211358776][]

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 son;
    	Func(son);
    }

![image-20230418211823912][]

这里我们要知道一个结论，满足多态的函数调用不是在编译时确定的，是运行起来以后到对象中去找的。不满足多态的函数调用是编译器编译时确认好的

#### 4.3 动态绑定与静态绑定 ####

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

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

#### 5.1 单继承中的虚函数表 ####

class Base {
    public:
    	virtual void func1() { cout << "Base::func1" << endl; }
    	virtual void func2() { cout << "Base::func2" << endl; }
    private:
    	int a;
    };
    class Derive :public Base {
    public:
    	virtual void func1() { cout << "Derive::func1" << endl; }
    	virtual void func3() { cout << "Derive::func3" << endl; }
    	virtual void func4() { cout << "Derive::func4" << endl; }
    private:
    	int b;
    };

![image-20230418214403541][]

通过监视窗口我们不能发现func3和func4这里是编译故意隐藏了这两个函数，我们可以打印出虚表中的函数：

typedef void(*VFPTR)();
    void PrintVFPTR(VFPTR vTable[])
    {
    	for (int i = 0; vTable[i] != nullptr; i++)
    	{
    		//printf("第%d个虚函数的地址：0X%x", i, vTable[i]);
    		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
    		VFPTR f = vTable[i];
    		f();
    	}
    	cout << endl;
    }
    
    int main()
    {
    	Base b;
    	Derive d;
    	VFPTR* vfptr = (VFPTR*)(*(int*)&b);
    	PrintVFPTR(vfptr);
    	return 0;
    }
    通过监视窗口我们不能发现func3和func4这里是编译故意隐藏了这两个函数，我们可以打印出虚表中的函数：
    
    // 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数
    
    //指针的指针数组，这个数组最后面放了一个nullptr
    
    // 1.先取b的地址，强转成一个int*的指针
    
    // 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
    
    // 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
    
    // 4.虚表指针传递给PrintVTable进行打印虚表
    
    // 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最
    
    //后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再
    
    //编译就好了。

![image-20230418220121537][]

#### 5.2 多继承中的虚函数表 ####

观察下图我们可以知道：多继承派生类未重写的虚函数放在第一个继承基类部分的虚函数表中

![image-20230419181642695][]

### 6 继承和多态常见面试题 ###

#### 6.1 概念 ####

1.  那种面向对象的方法可以让你变得富有：**继承**
2.  （**动态绑定**）是面向对象程序设计语言的一种机制。这种机制实现了方法的定义与具体的对象无关，而对方法的调用则可以关联具体的对象
3.  面向对象设计中的继承和组合，下面说法错误的是：**C**  
    A. 继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复用，也称为白盒复用  
    B. 组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动态复用，也称为黑盒复用  
    C. 优先使用继承，而不是组合，是面向对象设计的第二原则  
    D. 继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了子类封装的表现
4.  以下关于纯虚函数的说法正确的是：**A C**  
    A. 声明纯虚函数的类不能实例化  
    B. 声明纯虚函数的类是虚基类  
    C. 子类必须实现基类的纯虚函数  
    D. 纯虚函数必须是空函数
5.  关于虚函数的描述正确的是：**B**  
    A. 派生类的虚函数和基类的虚函数具有不同的参数个数和类型  
    B. 内联函数不能是虚函数  
    C. 派生类必须重定义基类的虚函数  
    D. 虚函数可以是一个`static`型的函数
6.  关于虚表的说法正确的是：**D**  
    A. 一个类只能有一张虚表  
    B. 基类中有虚函数，如果子类没有重写基类的虚函数，此时子类与基类共用一张虚表、  
    C. 虚表是在运行期间动态生成的  
    D. 一个类的不同对象共享该类的虚表
7.  假设A类中有虚函数， B继承A， B重写A中的虚函数，也没有定义任何的虚函数，则：**C**  
    A. A类对象的前四个字节存储虚表地址，B类对象的前四个字节不是虚表地址  
    B. A类对象和B类对象的前四个字节存储的都是虚基表的地址  
    C. A类对象和B类对象的前四个字节存储的虚表地址相同  
    D. A类和B类虚表中虚函数个数相同，但是A类和B类使用的不是同一张虚表

#### 6.2 问答题 ####

![0138066527b526524faafc5e9a0d05d6.png][]

[1c44674b34bd27a6928e24386c184189.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/9c6acd6064104a0c973e709ae75e2ad7.png
[cd056ad17a599d9aaa1a3f776289eaa0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/39ca1bf23187402198e31955f469509c.png
[image-20230417212726524]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/d30023302c3241b6b2c1b88b009365e0.png
[image-20230417214207708]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/c525791eeaa5473f9ce57c1d0d59f01b.png
[image-20230417214527153]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/7d3c2b52c0a6411eb74ef5781ef00b12.png
[image-20230417214616161]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/b8e4e2b700894ad9ab05b2c57e93627d.png
[image-20230418205156368]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/a5c582d071e9484eab799bfcc8569bef.png
[image-20230418211358776]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/faa7d1337369490caef8152e5dc7aa84.png
[image-20230418211823912]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/9ae28c2dde4442e59ac67e4e5cda1150.png
[image-20230418214403541]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/34cdfd490cb344fc99e6d73ab54f1dfe.png
[image-20230418220121537]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/ad25d22094ac4472b4b6458a28a3c679.png
[image-20230419181642695]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/2f41c6c9443c4648b8c2b9c3be098059.png
[0138066527b526524faafc5e9a0d05d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/f88e2112b8214b8daf59a1e1ac4be92a.png