C++多态

RXY24601

已于 2023-05-25 19:24:34 修改

阅读量453

点赞数

分类专栏： C++ 文章标签： c++ 开发语言

于 2023-05-21 21:14:21 首次发布

本文链接：https://blog.csdn.net/rxy24601/article/details/130753333

版权

C++ 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

一、多态的概念

通俗来说，就是多种形态。对于不同的对象同一行为会产生分异。通俗的理解就是见人下菜碟

比如银行对预约用户和VIP用户优先处理接见，普通用户需要排队取号等待。同样都是取款，VIP就是包间经理服务取款，普通用户就是大厅柜员服务取款

二、多态的实现

多态是在不同继承关系的类对象调用同一函数，产生的不同行为

在继承中构成多态的两个条件：

①被调用的函数必须是虚函数，并且子类必须对父类的虚函数进行重写（这里的虚函数与虚基类无关，只是共用关键字virtual。虚基类是用于解决二义性问题的）

②必须通过父类的指针或引用调用虚函数

虚函数：是指被virtual修饰的类函数。虚函数的重写要求函数名、参数、返回值都相同

虚函数存在的意义就是为了实现重写，而重写的目标就是实现多态

注意这里虚函数的重写与函数重载并不一样。函数重载是在同一个作用域内，而重写也叫覆盖

在子类重写父类虚函数的时候，虽然不写virtual关键字也会被编译器处理为重写父类虚函数的实现，但是代码不够规范，一般还是写上

虚函数重写的特例：

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

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

2.析构函数的重写

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

三、override和final

final关键字

用于修饰类或函数

当final用于修饰类时，这个类被称为最终类，不能再继承

当final用于修饰虚函数时，这个虚函数也不可以再被重写覆盖

override关键字

用于修饰虚函数

override用于检查子类虚函数是否重写了父类的某个虚函数，如果没有重写则编译报错

#include<iostream>
using namespace std;

class Person
{
public:
	virtual void show_1()
	//virtual void show_1 ()final 子类重写虚函数会报错
	{
		cout << "this is Person" << endl;
	}
	virtual void show_2()
	//void show_2() override报错，未进行重写
	{
		cout << "Student" << endl;
	}
};

class Student:public Person
{
public:
	virtual void show_1() 
	{
		cout << "this is Student" << endl;
	}
	virtual void show_2()override
	{
		cout << "Student" << endl;
	}
};


int main()
{
	Student s1;
	s1.show_1();
	s1.show_2();
	return 0;
}

四、抽象类

纯虚函数：在虚函数后面加上=0，则这个函数就是纯虚函数

包含纯虚函数的类就叫抽象类，抽象类不能实例化对象

#include<iostream>
using namespace std;


class people//包含纯虚函数，为抽象类，不能实例化对象
{
public:
	virtual void speak() = 0;//speak为纯虚函数
};


class student:public people//student继承people类
	//如果没有重写speak则为抽象类，因为会隐藏基类纯虚函数speak
	//如果重写speak且speak不为纯虚函数，则不是抽象类
{
public:
	virtual void speak()
	{
		cout << "student speak" << endl;
	}
};
void test_1()
{
	//people p1;//报错，不允许使用抽象类people
	student s1;
	s1.speak();
}

int main()
{
	test_1();

	return 0;
}

五、多态原理

前提引入：

对于一个包含虚函数的类的大小该怎么计算？

#include<iostream>
using namespace std;

class size_test
{
public:
	virtual void size_testNum()
	{

	}
private:
	int _a = 1;
	char _b = 'c';
};

void test_sizeNum()
{
    size_test s1;
	cout << sizeof(size_test) << endl;
	
}

int main()
{
	test_sizeNum();
	return 0;
}

以上面这个测试案例为例，按照传统的类的大小计算，应该是4+1再由内存补齐为8。但是在x86下实际的测试结果是12

在监视窗口下可以看出，除了_a _b外还有一个_vfptr指针，所以实际上是4+4+4=12

这个_vfptr叫做虚函数表指针（virtual function pointer）。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表

原理分析：

虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr

当一个子类继承了一个包含虚函数的父类时，它也会继承父类的虚函数表，并且会覆盖其中任何重写的虚函数。如果子类中没有重写任何虚函数，那么它的虚函数表将于父类的虚函数表完全相同，并且子类不需要为此生成自己的虚函数表指针

同类型的对象共享同一个序表

这也同样解释类多态形成的条件：①派生类必须重写基类虚函数②调用必须采用基类的指针或引用，因为本质上都是对基类的虚函数进行调用，只是派生类重写后替换了派生类序表中的虚函数表指针

注意：

①是虚函数表指针存放在虚表中，并不是虚函数存放在虚表中

②虚函数与普通函数一样都具有代码段，存放在常量区

③虚表是在类编译阶段生成的

④对象中的虚表指针是在构造函数的初始化列表隐式进行初始化

⑤虚表并不存放在类内，虚表存储在常量区

虚表打印：

#include<iostream>
using namespace std;

class Base
{
public:
	Base()
		:_b(10)
	{
		++_b;
	}

	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 son :public Base
{
public:
	virtual void func1()
	{
		cout << "son::func1()" << endl;
	}
	virtual void func4()
	{
		cout << "son::func4()" << endl;
	}
};

//打印虚表
typedef void(*VF_PTR)();//函数指针
void printVFTable(VF_PTR table[])
//相当于void printVFTable(VF_PTR* table)
{
	for (int i = 0; table[i]!=nullptr; i++)
	{
		printf("[%d]: %p->", i,table[i]);
		VF_PTR f = table[i];//函数指针指向虚表中的函数
		f();//函数调用
		
	}
	printf("\n");
}

int main()
{
	Base b;
	son s;
	printVFTable((VF_PTR*)(*(int*)&b));
	//逻辑是，取b的地址，b的地址类型为VF_PTR*，将其强转成int*类型，这样就只有四个字节
	//再解引用后转为VF_PTR*类型传参，VF_PTR*就是虚表的地址
	printVFTable((VF_PTR*)(*(int*)&s));


	return 0;
}

上面这段代码实现了虚表的打印