到底多态有多难

1.概念

多态----简单来说就是一种事物具有多种形式或者形态的特征，好比我们生活中最简单的事物，就像每天都会用到的水，水有三态，即固态、液态和气态。生活中这种多多态的例子很多，同样在我们C++的学习过程中，多态也是一种面向对象编程的一种不可缺少的特性。

2.多态的分类

多态从系统实现的角度来看，可分为静态多态和动态多态，而静态多态中又包括函数重载和模板（也叫泛型编程），动态多态中主要是我们接下来主要介绍的虚函数。

那么具体的什么是静态多态呢？

（1）静态多态---所谓静态多态是指在编译器编译期间完成，编译器根据函数实参的类型（包括隐式的类型转化），可确定该变量或者参数的类型，同时由此也能确定函数在执行阶段具体要调用的是那个函数，因此又称编译时的多态性。

a.根据编译器的推断调用对应类型的函数

<span style="font-size:24px;"><span style="font-size:18px;">int Add(int left, int right)
{
	return left + right;
}
float Add(float left, float right)
{
	return left + right;
}

int main()
{
	cout<<Add(10, 20)<<endl;
	cout<<Add(10.5f, 3.5f)<<endl;
	return 0;
}</span></span>

运行结果为

编译器在下面根据实参的类型，在编译阶段就知道要调用那个函数

b.函数重载

如下赋值运算符的重载

<span style="font-size:24px;"><span style="font-size:18px;">class A
{
public:
	A():_data(0)
	{
		cout<<"A()"<<endl;
	}
	A& operator=(const A& s)
	{
		if(this != &s)
		{
			_data = s._data;
		}
		return *this;
	}
private:
	int _data;
};

int main()
{
	A a;
	A b;
	b = a;
	return 0;
}</span></span>

（2）动态多态---和静态多态的最大区别是，动态多态实在程序具体的执行期间，才能判断出所引用的实际类型，进而才能确定要调用那个函数，因此又称运行时的多态性。

利用虚函数实现动态多态性

谈到虚函数实现动态性的问题，首先我们需要解决的首要问题就是要知道，什么是虚函数，以及虚函数有什么作用，通过先搞清楚这些基本的知识点，我们才能进一步的去探索虚函数实现动态多态性。

A-->虚函数：虚函数很简单，通过在可以定义为虚函数的的函数前面加上定义虚函数的关键字virtual，这样我们就可以完成一个虚函数的定义或者说是虚函数的声明。

注意虚函数定义时蓝色字体部分，什么叫可以定义为虚函数的函数，难道不是在需要定义为虚函数的函数前面加上一个虚函数的关键字构成一个虚函数的定义，这一点是当然的虚函数的定义也是有一定的硬性要求，下面我们就来一一解释一下其中的要求

虚函数必须是在基类中用visual声明的成员函数下面先实现一个简单的虚函数

class Base
{
public:
	virtual void FunTest()
	{
		cout<<"Base::FunTest"<<endl;
	}
private:
	int _b;
};

class Derived:public Base
{
	public:
	virtual void FunTest()
	{
		cout<<"Derived::FunTest"<<endl;
	}
private:
	int _d;
};

这个继承中我们给基类的成员函数定义前加上了virtual关键字使它构成了虚函数。

但是有几个特例是不能被声明为虚函数的，这也是在虚函数面试中经常被问到的问题，我们分别将其检测一下，并做一些简要的分析

（1）静态函数不能做虚函数

<span style="color:#333333;">class Base
{
public:
	virtual void FunTest()
	{
		cout<<"Base::FunTest"<<endl;
	}
	virtual static void FunTest1()
	{
		cout<<"Base::FunTest1"<<endl;
	}
	
private:
	int _b;
};

class Derived:public Base
{
	public:
	virtual void FunTest()
	{
		cout<<"Derived::FunTest"<<endl;
	}
private:
	int _d;
};</span><span style="color:#ff0000;">
</span>

当我们在编译的过程中，编译器就会给我们指出下面这样一条错误

根据这条错误提示，很明显静态函数是不能作为虚函数的，原因应该是这样的，静态函数中没有隐含的this指针，所以他并不满足是类的成员函数这一条，所以它并不能构成虚函数；另一方面静态函数应该和静态变量一样做为全局性的函数和变量，它的类型是在编译阶段就被确定下来的，从而也可以说明它不能定义成虚函数

（2）构造函数不能做虚函数（拷贝构造函数同样也不行）

<span style="color:#333333;">class Base
{
public:
	virtual Base()
	{}
	virtual void FunTest()
	{
		cout<<"Base::FunTest"<<endl;
	}
private:
	int _b;
};

class Derived:public Base
{};</span>

同样当我们编译时，编译器就会给我们指出下面这样一条错误：

第一方面：构造函数的作用，是在创建对象时对对象进行初始化，而构造一个对象时就必须知道对象的实际类型，而虚函数是在运行时期才能确定实际类型的，在构造对象时，由于对象还没有构造成功，编译器无法知道对象的实际类型

第二方面虚函数执行依赖于虚函数表，虚函数表在构造函数中进行初始化工作，而在构造对象期间，虚函数表还没有被初始化，因此也不能进行构造

（3）类的友元函数不能做虚函数

这个例子，然后在写一个虚拟的友元函数将两者对比来说明，友元函数为什么不能被定义为虚函数

<span style="color:#333333;">class Base
{
public:
	/*普通友元函数*/friend ostream& operator<<(ostream& _cout, const Base& b);
private:
	int _b;
};

class Derived:public Base
{};</span>

编译一下我们看到程序正确的通过了编译

<span style="font-size:24px;">class Base
{
public:/*虚友元函数*/
	virtual friend ostream& operator<<(ostream& _cout, const Base& b);
private:
	int _b;
};

class Derived:public Base
{};</span>

经过编译，编译器给我们提示出了这样的错误，根据提示我们可以知道友元函数并不是基类成员，其本身也不包含this指针，因此它也不能作为虚函数

B---> 上面简单的介绍了一下虚函数，下面我们将探讨一下 虚函数在程序中的作用

用一句概括性的话来描述，虚函数是用来允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问的基类和派生类中的同名函数

提到使用同名函数这个问题，我们有必要将C++继承体系中几种使用同名函数的情景跟大家好好分享一下，具体关系如下图所示：

在虚函数中还有一个常用的虚函数，叫做纯虚函数

纯虚函数：

（1）在成员函数的形参后面写上=0，则成员函数为纯虚函数。

class Base 
{
public:
	virtual void FunTest() = 0;//纯虚函数
private:
	int _b;
};
class Derived:public Base
{};

（2）包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。

class Base 
{
public:
	virtual void FunTest() = 0;//纯虚函数
private:
	int _b;
};
class Derived:public Base
{};

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

经过编译之后，说明抽象类确实不能实例化出对象。

（3）纯虚函数在派生类中重新定义以后，派生类才能实例化出对象。

class Base 
{
public:
	virtual void FunTest() = 0;//纯虚函数
private:
	int _b;
};
class Derived:public Base
{
	virtual void FunTest()
	{
		cout<<"FunTest()"<<endl;
	}
};

int main()
{
	Derived d;
	return 0;
}

经过编译，我们看到在派生类中重新定义的FunTest函数可以创建出对象d

关于虚函数的几点说明：

（1）基类中定义了虚函数，在派生类中该函数也始终保持虚函数的特性；

（2）如果在类外定义虚函数，只能在声明函数时加virtual关键字，定义时可加可不加；

（3）最好不要在构造函数和析构函数中调用虚函数，因为在构造函数和析构函数中，对 象是不完整的，可能会发生未定义的错误；

（4）建议将析构函数声明为虚函数；

（5）虚表是所有类对象实例共用的。