多态深度剖析

前言

继承是多态的基础，

如果对于继承的知识还不够了解，

可以去阅读上一篇文章

继承深度剖析

基本概念与定义

概念：

通俗来说，就是多种形态。具体点就是去完成某个行为，

当不同的对象去完成时会产生出不同的状态。

举个栗子：

比如买票这个行为，当普通人买票时，是全价买票；

学生买票时，是半价买票；

军人买票时是优先买票。

构成多态的两个必要条件：

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

那么，什么是虚函数？什么是重写？

将virtual关键字加在成员函数前面，这个函数就是虚函数

虚函数的重写（覆盖）

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

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

实例

使用多态时，切记要注意构成多态的两个必要条件

实例

class Person
{
public:
	virtual void Buy()
	{
		cout << "全价" << endl;
	}
};

class student :public Person
{
public:
	virtual void Buy()
	{
		cout << "半价" << endl;
	}
};

int main()
{
	Person p;
	student s;
	p.Buy();
	s.Buy();
	return 0;
}

运行结果

p 是基类 Person 的实例，s 是派生类 Student 的实例。

当 p 调用 Buy 函数时，它调用的是 Person 类中的函数，

因此输出 “全价”。而当 s 调用 Buy 函数时，

它调用的是 Student 类中的重写函数，因此输出 “半价”。

通过重写基类中的虚函数，派生类可以改变函数的行为，这就是多态性。

尽管 p 和 s 都调用了 Buy 函数，但由于它们所属的类不同，输出的结果也不同。

构成多态的两个特例

1.派生类虚函数不写virtual关键字依旧构成多态

2.基类与派生类虚函数返回值类型不同
也可以构成多态(返回值必须满足某种条件)

基类的返回值要返回基类
派生类的返回值要返回派生类

注意

1.父类不写virtual,而子类的同名
函数写了virtual,这是不构成多态的!

class Person
{
public:
	void Buy()
	{}
};

class student :public Person
{
public:
	virtual void Buy()
	{}
};

2.在继承体系中,父子类的同名
函数不构成重写就构成隐藏,不可能构成重载!

底层原理分析

大家先思考一下这套题目的答案，

如果你单纯的认为Base类只有一个
整型变量占用空间,答案是4的话,那你就上当啦!
事实上在32位机器下,这里的结果是8
在64位机器下,这里的结果是16!

因为它除了有一个变量外,还有
一个指针,此指针指向一个虚函数表

使用这一段代码观察

class A
{
public:
	virtual void func1()
	{
		cout << "父类func1";
	}
private:
	int _a;
};
class B : public A
{
public:
	virtual void func1()
	{
		cout << "子类func1";
	}
private:
	int _b;
};

int main()
{
	A a;
	B b;
	return 0;
}

此指针叫虚表指针:vfptr,也就是
virtual function ptr

这个指针并不是直接指向虚函数的地址
而是指向一个虚函数表,可以理解位一个
数组,此数组中存放着此对象中所有的虚
函数的地址,它们的关系可以用下图表示:

注:不管有没有继承体系或多态
只要有虚函数就有虚表!

那么父类和子类的虚表指针和指向
的内容有什么不同或相同处吗?
形成多态现象的原理又是什么?

class A
{
public:
	virtual void func1()
		cout << "父类func1";
	virtual void func2()
		cout << "父类func2";
private:
	int _a;
};
class B : public A
{
public:
	virtual void func1()
		cout << "子类func1";
private:
	int _b;
};
int main()
{
	A a;
	B b;
	return 0;
}