【C++】：多态的使用及原理解析

24k纯甄

于 2024-07-14 13:13:36 发布

阅读量817

点赞数 62

文章标签： c++ 开发语言 windows

本文链接：https://blog.csdn.net/2301_77900444/article/details/140398970

版权

🚀前言

多态是C++的三大特性之一，也是面向对象的重要体现。在生活中的某些特定场合就能够体现出多态。

比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

再比如动物发出叫声这一行为，小狗叫是"汪汪"，小猫叫是"喵喵"。

上述例子都能体现出不同的对象去完成同一个行为，结果不同。

一，多态的概念

不同类型的对象去完成同一个行为，结果会产生不同的形态。

二，多态的定义及实现

比如使用多态完成买票行为：

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

class Soldier : public Person
{
public:
	virtual void BuyTicket() 
	{ 
		cout << "买票-优先" << endl;
    }
};

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

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

//void Func(Person* p)
//{
//	p->BuyTicket();
//}

int main()
{
	Person p;
	Student st;
	Soldier so;

	//Func(p);
	//Func(s);

	Func(&so);
	Func(&st);
	
	return 0;
}

在这里插入图片描述

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

多态调用：看指向对象类型，指向谁就调用谁的虚函数。
普通调用：看调用者的类型，调用调用者的函数。

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

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

2.1 虚函数

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

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

2.2 虚函数的重写

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

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

class Student : public Person 
{
public:
 virtual void BuyTicket() 
 { 
 	cout << "买票-半价" << endl; 
 }
	
	//前面不加virturl，此时也构成重写
	//void BuyTicket() 
	//{ 
    //	cout << "买票-半价" << endl; 
	//}
 };

注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，也可以构成重写(因为此时是用(继承了)父类的接口声明 + 子类重写了函数实现)，但是该种写法不是很规范，不建议这样使用。

虚函数重写的两个例外：

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

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

class A{};
class B : public A {};

class Person {
public:
 virtual A* f() {return new A;}
};

class Student : public Person {
public:
 virtual B* f() {return new B;}
};

(2) 析构函数的重写(基类与派生类析构函数的名字不同)

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

可以用下面的例子来解释析构函数重写的必要性：

(1) 正常情况下：

class Person 
{
public:
	  ~Person() 
	{ 
		cout << "~Person()" << endl; 
	}
};

class Student : public Person 
{
public:
	~Student() 
	{ 
		delete _ptr;
		cout << "~Student()" << endl; 
	}
protected:
	int* _ptr = new int[10];
};

int main()
{
	//父类析构不加virtual时：
	Student s; //ok

	return 0;
}

在这里插入图片描述

调用析构函数先子后父，子类调用完后自动调用父类析构，子类中的资源清理完成，这是调用正常的。

(2) 两个类不构成多态时：

class Person 
{
public:
	 ~Person() 
	{ 
		cout << "~Person()" << endl; 
	}
};

class Student : public Person 
{
public:
	~Student() 
	{ 
		delete _ptr;
		cout << "~Student()" << endl; 
	}
protected:
	int* _ptr = new int[10];
};

int main()
{
	//此时p1指向的是一个子类的对象，但调的却是父类的析构函数
	//如果像上面的子类，就无法清理资源，会发生内存泄漏
	Person* p1 = new Student;

	delete p1;

	return 0;
}

在这里插入图片描述

此时p1指向的是一个子类的对象，但调的却是父类的析构函数，没有调用子类的析构，就无法清理资源，会发生内存泄漏。

(3) 两个类构成多态时：

class Person 
{
public:
	 virtual ~Person() 
	{ 
		cout << "~Person()" << endl; 
	}
};

class Student : public Person 
{
public:
	~Student() 
	{ 
		delete _ptr;
		cout << "~Student()" << endl; 
	}
protected:
	int* _ptr = new int[10];
};

int main()
{
	Person* p1 = new Student;
	
	// p1->destructor() + operator delete(p1)
	delete p1;

	//如果本身指向的是一个父类的对象，调的只是父类的析构函数

	return 0;
}

在这里插入图片描述

在派生类对基类的析构进行重写后，p1是父类的指针，就满足了多态，p1指向的是子类，指向谁就调用谁的析构函数，避免了内存泄漏。

2.3 C++11 override 和 ﬁnal

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

(1) ﬁnal：修饰虚函数，表示该虚函数不能再被重写

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

class Benz :public Car
{
public:
 virtual void Drive() 
 {
 	cout << "Benz-舒适" << endl;
 }
};

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

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

class Benz :public Car 
{
public:
 virtual void Drive() override 
 {
 	cout << "Benz-舒适" << endl;
 }
};

(3) 要想一个类不能被继承：

1.在父类后面加 final，变成最终类。

2. 把父类的构造私有化(间接)，从而导致子类的构造无法生成和实现，导致子类对象无法实例化。

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

(1) 重载：两个函数在同一作用域，函数名相同，参数不同。

(2) 重写：两个函数分别在基类和派生类的作用域，函数名，参数，返回值都必须相同(协变例外)，并且两个函数必须的虚函数。

(3) 重定义(隐藏)：两个函数分别在基类和派生类的作用域，函数名相同。两个基类和派生类的同名函数不构成重写就是重定义重写是特殊的重定义。

三，抽象类

3.1 概念

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。

(1) 派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。

(2) 纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

(3) 纯虚函数不需要函数体，只要声明即可，可以有函数体，只是意义不大。

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()
{
	Benz bz;

	return 0;
}

3.2 接口继承和实现继承

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

四，多态的原理(重点)

4.1虚函数表

// 这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
 virtual void Func1()
 {
 cout << "Func1()" << endl;
 }
private:
 int _b = 1;
};

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

在这里插入图片描述

针对上面的代码我们做出以下改造：
1.我们增加一个派生类Derive去继承Base；
2.Derive中重写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) 这里还有一个很容易混淆的问题：虚函数存在哪的？虚表存在哪的？

注意：
虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针(对象的前4个字节是虚表的指针)。那么虚表存在哪的呢？

实际我们去验证一下会发现vs下是存在代码段(常量区)的。

//确定虚表存在的位置
int main()
{
	int i = 0;
	static int j = 0;
	int* p1 = new int;
	const char* p2 = "11111111";

	printf("栈:%p\n", &i);
	printf("静态区:%p\n", &j);
	printf("堆:%p\n", p1);
	printf("常量区:%p\n", p2);
	cout << endl;

	Base b;
	Derive d;

	printf("Base虚表地址:%p\n", (*(int*)&b));
	printf("Derive虚表地址:%p\n", (*(int*)&d));
	cout << endl;

	printf("Base对象地址:%p\n", &b);
	printf("Derive对象地址: %p\n", &d);
	cout << endl;

	return 0;
}

在这里插入图片描述

总结：
(1) 虚表存在常量区/代码段；
(2) 虚函数的指针存在虚表中；
(3) 虚函数和普通函数存在代码段；
(4) 对象中存的是虚表的指针；
(5) 同一个类型的对象是共享虚表；
(6) 广义上还有一些静态多态：函数重载，函数模板

4.2多态的原理

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

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;
}

(1) 观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。

(2) 观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。

(3) 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。

(4) 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？

(5) 再通过汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。

在这里插入图片描述

4.3 动态绑定与静态绑定

(1) 运行时绑定/动态绑定：
满足多态，那么这里调用生成的指令时，运行时就会去指向对象的虚表中找到对应的虚函数的地址，指向谁调用谁。

(2) 编译时绑定/静态绑定：
不满足多态，普通函数的调用，如果只有声明，就通过函数名在链接的时候找到地址调用，如果有声明和定义，就通过函数名在符号表中找到地址，跟指向的对象无关。

五，多继承的虚表

假设D类先继承B1，然后继承B2，B1和B2基类均包含虚函数，D类对B1和B2基类的虚函数重写了，并且D类增加了新的虚函数，则：

D类对象有两个虚表，D类新增加的虚函数放在第一张虚表最后。

原因：
(1) D类有几个父类，如果父类有虚函数，则就会有几张虚表，自身子类不会产生多余的虚表，所以只有2张虚表。

(2) 子类自己的虚函数只会放到第一个父类的虚表后面，其他父类的虚表不需要存储，因为存储了也不能调用。

24k纯甄

关注

62
点赞
踩
51

收藏

觉得还不错? 一键收藏
47
评论
【C++】：多态的使用及原理解析

多态是C++的三大特性之一，也是面向对象的重要体现。在生活中的某些特定场合就能够体现出多态。比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。再比如动物发出叫声这一行为，小狗叫是"汪汪"，小猫叫是"喵喵上述例子都能体现出不同的对象去完成同一个行为，结果不同。public:cout << "买票-全价" << endl;public:cout << "买票-优先" << endl;public:cout << "买票-半价" << endl;
复制链接

扫一扫