C++多态知识总结

最新推荐文章于 2022-11-15 20:06:19 发布

CyanWang1

最新推荐文章于 2022-11-15 20:06:19 发布

阅读量321

点赞数

分类专栏： C++

本文链接：https://blog.csdn.net/CyanWang1/article/details/97395387

版权

C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

前言：本文中的代码及解释都是在vs2017下的x86程序中，涉及的指针都是4bytes。

1.多态概念

1.1概念
多态通俗来说就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。比如在windows下双击一个文件，如果对象是个可执行文件，则会执行此程序，如果对象是个目录文件，则会打开这个目录。
在C++中，所谓多态性是指：由继承而产生的不同的派生类，其对象对同一消息会做出不同的响应。

2.多态的定义及实现

2.1多态的构成条件
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。
在继承中要构成多态还有两个条件：
（1）被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
（2）必须通过基类的指针或者引用调用虚函数
2.2虚函数
被virtual修饰的类成员函数称为虚函数。

class Person{
publc:
	virtual void BuyTicket(){
		cout<<"成人票"<<endl;
	}
};

2.3虚函数的重写
虚函数的重写也称为虚函数的覆盖，派生类中有一个跟基类完全相同的虚函数（完全相同指的是派生类的虚函数与基类的虚函数的返回值类型、函数名称、参数列表完全相同），此时，称子类的虚函数重写了基类的虚函数。

class Person{
public:
	virtual void BuyTicket(){
		cout<<"成人票"<<endl;
	}
};
//注意：在重写基类的虚函数时，派生类的虚函数不加virtual关键字也可以构成重写
//（因为基类的虚函数被继承到派生类中了，在派生类中依然保持虚函数属性），
//但这种写法不规范，如多重继承时将函数是否是虚函数将不清晰
class Student:public Person{
public:
	virtual void BuyTicket(){
		cout<<"学生票"<<endl;
	}
};

void Func(Person& p){
	p.BuyTicket();
}

int main(){
	Person ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

虚函数重写两个例外：
(1).协变（基类与派生类虚函数的返回值类型不同）
(2).析构函数的重写（基类与派生类析构函数的名字不同）
如果基类的析构函数为虚函数，此时派生类析构函数只要定义了，无论是否加virtual关键字，都与基类的析构函数构成重写。看起来违背了重写的规则，其实可以理解为编译器对析构函数的名字做了特殊处理，编译后析构函数的名称统一处理成destructor。

class Person{
public:
	virtual ~Person(){
		cout<<"~Person()"<<endl;
	}
};
//只有派生类Student的析构函数重写了基类Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确调用析构函数。
class Student:public Person{
public:
	~Student(){
		cout<<"~Student()"<<endl;
	}
};

int main(){
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;
	return 0;
}

2.4 C++11 override和final
需要注意的是如由于函数名字次序写反而无法构成重写，这种错误在编译期间是无法报出的，因此，C++11提供了override和final两个关键字，可以帮助用户检查是否重写。

//final:修饰虚函数，表示该虚函数不能被继承
class Car{
public:
	virtual void Drive() final{}
};

//override:检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。
class Car{
public:
	virtual void Drive() {}
};

class BMW{
public:
	virtual void Drive()override{
		cout<<"good"<<endl;
	}
};

2.5 重载、覆盖（重写）、隐藏（重定义）的对比
在这里插入图片描述

3.抽象类

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

class Car{
public:
	virtual void Drive() = 0;
};

class BMW : public Car{
public:
	virtual void Drive(){
		cout<<"cool"<<endl;
};

class Maserati : public Car{
public:
	virtual void Drive(){
		cout<<"coolest"<<endl;
};

void Test（）{
	Car* pBMW = new BMW;
	pBMw->Drive();

	Car* pMaserati = new Maserati;
	pMaserati->Drive();

3.2接口继承和实现继承
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态。所以当需要实现多态的时候，再把函数定义成虚函数。

4.多态原理

4.1虚函数表

//sizeof(Base)是多少？
class Base{
public:
	virtual void Func1(){
		cout<<"Func1()"<<endl;
	}
private:
	int _b = 1;
};

int main(){
	Base b;
	return 0;
}

测试后结果是8bytes,除了_b成员，还多了一个_vfptr在对象前面，对象中的这个指针叫做虚函数表指针（v代表virtual,f代表function）。一个含有虚函数的类中都至少有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表简称虚表。
在这里插入图片描述
对这个虚表进行分析：

//1.增加一个派生类去继承Base
//2.派生类中重写Func1
//3.Base中再增加一个虚函数Func2和一个普通函数Func3
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<<"Derive::Func1()"<<endl;
	}
private:
	int _d = 2;
};

int main(){
	Base b;
	Derive d;
	return 0;
}

在这里插入图片描述
通过观察测试，发现以下几点：
1.派生类对象d中也有一个虚表指针，d对象由两部分组成，一部分是父类继承下来的成员，虚表指针也就其中的部分，另一部分是自己的成员。
2.基类b对象和派生类d对象的虚表是不同的，代码中Func1完成了重写，所以d的虚表中存的是重写后的Derive::Func1,所以虚函数的重写也叫做覆盖，覆盖即指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
3.父类中Func2是虚函数，继承后放进了虚表，Func3也继承了下来，但因不是虚函数，所以未放入虚表。
4.虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。
5.总结派生类的虚函数表的生成：a.先将基类中的虚表内容拷贝一份放到派生类虚表中；b.如果派生类重写了基类中某个虚函数，则用派生类自己的虚函数覆盖虚表中基类的虚函数；c.派生类中自己新增的虚函数按照其在派生类中的声明次序增加到派生类虚表的最后。
6.一个容易混淆的问题：虚函数存在哪？虚表存在哪？
虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样都存在代码段中，只是指针存在了虚表中。另外对象中存的是虚表指针。VS下，虚表也存在代码段。

4.2多态原理

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 Wang;
	Student XiaoZhang;
	
	Func(Wang);
	Func(XiaoZhang);
	return 0;
}

在这里插入图片描述
1.看红色箭头，p是指向Wang对象时，p.BuyTickrt在Wang的虚表中找到的虚函数是Person::BuyTicket。
2.看绿色箭头，p是指向XiaoZhang对象时，p.BuyTickrt在XiaoZhang的虚表中找到虚函数是Student::BuyTicket。
3.这样就实现了不同对象去完成同一行为时，展现不同的形态。
4.满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象中取找的。不满足多态的函数调用是在编译时确认好的。
在这里插入图片描述

void Func(Person* p){
	p.BuyTicket();
}

int main(){
	Person Wang;
	Func(Wang);
	Wang.BuyTicket();
	
	return 0;
}

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::func3"<<endl;
	}
private:
	int b;
};

在这里插入图片描述
在VS的监视窗口中看不见func3和func4。这里是编译器的监视窗口隐藏了这两个函数，也可以认为是一个bug。下面通过代码打印虚表中的函数。

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;
	Derive d;
	//思路：取出b、d对象的头4个bytes，就是虚表的指针，虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr
	//1.先取b的地址，强转成一个int*的指针
	//2.再解引用取值，就取到了b对象头4个bytes，这个值就是指向虚表的指针
	//3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型（虚函数指针类型）的数组
	//4.虚表指针传递给PrintVTable进行打印虚表
	VFPTR* vTableb = (VFPTR*)(*(int*)&b);
	PrintVTable(vTableb);

	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
	PrintVTable(vTabled);
	return 0;
}