C++基础：多态和虚函数的使用

多态与虚函数的使用：

多态性是面向对象程序设计的关键技术之一。若程序设计语言不支持多态性，不能称为面向对象的语言。

利用多态性技术，可以调用同一个函数名的函数，实现完全不同的功能。
1.函数名相同
2.参数列表相同
3.返回值相同

在C++中有两种多态性 ：

1.编译时的多态性：程序可以根据函数名和参数来确定该调用哪一个函数，它是通过函数的重载和运算符的重载来实现的。

2.运行时的多态性：运行时的多态性是指在程序执行前，无法根据函数名和参数来确定该调用哪一个函数，必须在程序执行过程中，根据执行的具体情况来动态地确定。

它是通过类继承关系和虚函数来实现的。目的也是建立一种通用的程序。通用性是程序追求的主要目标之一。

如何实现多态性：

1.继承
2.父类把成员函数写成虚函数
3.子类重写父类的该成员函数，即虚函数
3.通过父类的指针或引用调用子类的重写函数

当在派生类中重新定义虚函数时，不必加关键字virtual。但重新定义时不仅要同名，而且它的参数表和返回类型全部与基类中的虚函数一样，否则联编时出错。

同名隐藏：重写父类的一般函数，函数名相同，参数列表和返回值无影响

覆盖：重写父类的虚函数，函数名，参数列表，返回值都相同

重载：在相同的一个类里重写函数，只有函数名相同，参数列表不同，返回值无影响

虚函数是一个类的成员函数，定义格式如下：

virtual 返回类型 函数名（参数表）；

关键字virtual指明该成员函数为虚函数。
virtual仅用于类定义中，如虚函数在类外定义，不可加virtual。

当某一个类的一个类成员函数被定义为虚函数，则由该类派生出来的所有派生类中，该函数始终保持虚函数的特征。

<span style="font-size:18px;">
#include <iostream>
using namespace std;

class Base
{
public:
	 virtual void show()    //虚函数
	{
		cout<<"This is Base show()"<<endl;
	}
};
class D : public Base
{
public:
	void show()
	{
		cout<<"This is D show()"<<endl;
	}
	
};

int main()
{
	D d;
	Base b;
	b = d;           //1.

	Base *pb = &d;   //2.
	pb->show();      //在父类的方法没有virtual关键字时，只能访问父类的show（）方法，
			 //但加上virtual时，父类的show()方法变成了虚函数，将访问子类的show()方法

	Base &bf = d;    //3.和2相同
	bf.show();    
}
</span>

根据赋值兼容规则，1，2，3是正确的，而根据2和3可以实现多态

多态举例：

<span style="font-size:18px;">class A
{
public:
	virtual void Eat()
	{
		cout<<"A Eat()"<<endl;
	}
	virtual void Sleep()
	{
		cout<<"A Eat()"<<endl;
	}
};
class P : public A
{
public:
	void Eat()
	{
		cout<<"P Eat()"<<endl;
	}
	void Sleep()
	{
		cout<<"P Eat()"<<endl;
	}
};
class Dog : public A
{
public:
	void Eat()
	{
		cout<<"Dog Eat()"<<endl;
	}
	void Sleep()
	{
		cout<<"Dog Eat()"<<endl;
	}
};
class Pig : public A
{
public:
	void Eat()
	{
		cout<<"Pig Eat()"<<endl;
	}
	void Sleep()
	{
		cout<<"Pig Eat()"<<endl;
	}
};

class Bird() : public A
{
public:
	void Eat()
	{
		cout<<"Bird Eat()"<<endl;
	}
	void Sleep()
	{
		cout<<"Bird Eat()"<<endl;
	}
	void Fly()	
	{
		cout<<"Bird Fly()"<<endl;
	}	
};

class TN() : public Bird
{
private:
	void Fly()		
};

//相同的函数实现不同的功能
void fun(A *pa)
{
	pa->Eat();
	pa->Sleep();
}

int main()
{
	P p;
	Dog dog;
	Pig pig;

	fun(&p);
	fun(&dog);
	fun(&pig);

	TN tn;
	tn.Fly();     //错误，不能调用

	return 0;
}</span>

有的时候继承的成员，子类不一定有，可以给该成员加一个私有属性就可以了。

成员函数应尽可能地设置为虚函数，但必须注意以下几条：

1.派生类中定义虚函数必须与基类中的虚函数同名外，还必须同参数表，同返回类型。否则被认为是重载，而不是虚函数。例外：基类中返回基类指针，派生类中返回派生类指针是允许的。

2.只有类的成员函数才能说明为虚函数。这是因为虚函数仅适用于有继承关系的类对象。

3.静态成员函数，是所有同一类对象共有，不受限于某个对象，不能作为虚函数。

4.一个类对象的静态和动态类型是相同的，实现动态多态性时，必须使用基类类型的指针变量或引用，使该指针指向该基类的不同派生类的对象，并通过该指针指向虚函数，才能实现动态的多态性。

5.内联函数每个对象一个拷贝，无映射关系，不能作为虚函数。

6.析构函数往往定义为虚函数，构造函数不能定义虚函数，因为在调用构造函数时对象还没有完成实例化。在基类中及其派生类中都动态分配的内存空间时，必须把析构函数定义为虚函数，实现撤消对象时的多态性。

7.虚函数执行速度要稍慢一些。为了实现多态性，每一个派生类中均要保存相应虚函数的入口地址表，函数的调用机制也是间接实现。所以多态性总是要付出一定代价，但通用性是一个更高的目标。

8.如果定义放在类外，virtual只能加在函数声明前面，不能（再）加在函数定义前面。正确的定义必须不包括virtual。

<span style="font-size:18px;">class Base
{
public:
	Base()
	{
		cout<<"Create Base"<<endl;
	}
	virtual ~Base()     //6.在基类中及其派生类中都动态分配的内存空间时，必须把析构函数定义为虚函数，实现撤消对象时的多态性
	{
		cout<<"Free Base"<<endl;
	}
};
class D : public Base
{
public:
	D()
	{
		cout<<"Create D"<<endl;
	}
	~D()
	{
		cout<<"Free D"<<endl;
	}
};

int main()
{
	Base *pb = new D;
	delete pb;

	return 0;
}</span>