浅谈C++多态性

　　最常见的使用方法就是声明基类的指针，利用该指针指向随意一个子类对象，调用对应的虚函数，能够依据指向的子类的不同而实现不同的方法。假设没有使用虚函数的话，即没有利用C++多态性，则利用基类指针调用对应的函数的时候，将总被限制在基类函数本身，而无法调用到子类中被重写过的函数。由于没有多态性，函数调用的地址将是一定的，而固定的地址将始终调用到同一个函数，这就无法实现一个接口，多种方法的目的了。

笔试题目：

#include<iostream>
using namespace std;

class A
{
public:
	void foo()
	{
		printf("1\n");
	}
	virtual void fun()
	{
		printf("2\n");
	}
};
class B : public A
{
public:
	void foo()
	{
		printf("3\n");
	}
	void fun()
	{
		printf("4\n");
	}
};
int main(void)
{
	A a;
	B b;
	A *p = &a;
	p->foo();
	p->fun();
	p = &b;
	p->foo();
	p->fun();
	return 0;
}

 
     第一个p->foo()和p->fuu()都非常好理解，本身是基类指针，指向的又是基类对象，调用的都是基类本身的函数，因此输出结果就是1、2。
 　  第二个输出结果就是1、4。p->foo()和p->fuu()则是基类指针指向子类对象，正式体现多态的使用方法，p->foo()因为指针是个基类指针，指向是一个固定偏移量的函数，因此此时指向的就仅仅能是基类的foo()函数的代码了，因此输出的结果还是1。而p->fun()指针是基类指针，指向的fun是一个虚函数，因为每一个虚函数都有一个虚函数列表，此时p调用fun()并非直接调用函数，而是通过虚函数列表找到相应的函数的地址，因此依据指向的对象不同，函数地址也将不同，这里将找到相应的子类的fun()函数的地址，因此输出的结果也会是子类的结果4。
　　笔试的题目中另一个另类測试方法。即

       B *ptr = (B *)&a;  ptr->foo();  ptr->fun();
　　问这两调用的输出结果。这是一个用子类的指针去指向一个强制转换为子类地址的基类对象。结果，这两句调用的输出结果是3，2。
　　并非非常理解这样的使用方法，从原理上来解释，因为B是子类指针，尽管被赋予了基类对象地址，可是ptr->foo()在调用的时候，因为地址偏移量固定，偏移量是子类对象的偏移量，于是即使在指向了一个基类对象的情况下，还是调用到了子类的函数，尽管可能从始到终都没有子类对象的实例化出现。
　　而ptr->fun()的调用，可能还是由于C++多态性的原因，由于指向的是一个基类对象，通过虚函数列表的引用，找到了基类中fun()函数的地址，因此调用了基类的函数。由此可见多态性的强大，能够适应各种变化，不论指针是基类的还是子类的，都能找到正确的实现方法。

//小结：1、有virtual才可能发生多态现象
// 2、不发生多态（无virtual）调用就按原类型调用
#include<iostream>
using namespace std;

class Base
{
public:
	virtual void f(float x)
	{
		cout<<"Base::f(float)"<< x <<endl;
	}
	void g(float x)
	{
		cout<<"Base::g(float)"<< x <<endl;
	}
	void h(float x)
	{
		cout<<"Base::h(float)"<< x <<endl;
	}
};
class Derived : public Base
{
public:
	virtual void f(float x)
	{
		cout<<"Derived::f(float)"<< x <<endl;   //多态、覆盖
	}
	void g(int x)
	{
		cout<<"Derived::g(int)"<< x <<endl;     //隐藏
	}
	void h(float x)
	{
		cout<<"Derived::h(float)"<< x <<endl;   //隐藏
	}
};
int main(void)
{
	Derived d;
	Base *pb = &d;
	Derived *pd = &d;
	// Good : behavior depends solely on type of the object
	pb->f(3.14f);   // Derived::f(float) 3.14
	pd->f(3.14f);   // Derived::f(float) 3.14

	// Bad : behavior depends on type of the pointer
	pb->g(3.14f);   // Base::g(float)  3.14
	pd->g(3.14f);   // Derived::g(int) 3 

	// Bad : behavior depends on type of the pointer
	pb->h(3.14f);   // Base::h(float) 3.14
	pd->h(3.14f);   // Derived::h(float) 3.14
	return 0;
}

令人迷惑的隐藏规则
本来只差别重载与覆盖并不算困难，可是C++的隐藏规则使问题复杂性陡然添加。
这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则例如以下：
（1）假设派生类的函数与基类的函数同名，可是參数不同。此时，不论有无virtual
keyword，基类的函数将被隐藏（注意别与重载混淆）。
（2）假设派生类的函数与基类的函数同名，而且參数也同样，可是基类函数没有virtual
keyword。此时，基类的函数被隐藏（注意别与覆盖混淆）。
上面的程序中：
（1）函数Derived::f(float)覆盖了Base::f(float)。
（2）函数Derived::g(int)隐藏了Base::g(float)，而不是重载。
（3）函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。

C++纯虚函数
 一、定义
  纯虚函数是在基类中声明的虚函数，它在基类中未定义，但要求不论什么派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”
  virtual void funtion()=0
二、引入原因
   1、为了方便使用多态特性，我们经常须要在基类中定义虚拟函数。
   2、在非常多情况下，基类本身生成对象是不合情理的。比如，动物作为一个基类能够派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。
  为了解决上述问题，引入了纯虚函数的概念，将函数定义为纯虚函数（方法：virtual ReturnType Function()= 0;），则编译器要求在派生类中必须予以重写以实现多态性。同一时候含有纯虚拟函数的类称为抽象类，它不能生成对象。这样就非常好地攻克了上述两个问题。
三、相似概念
   1、多态性
  指同样对象收到不同消息或不同对象收到同样消息时产生不同的实现动作。C++支持两种多态性：编译时多态性，执行时多态性。
  a、编译时多态性：通过重载函数实现
  b、执行时多态性：通过虚函数实现。
  2、虚函数
  虚函数是在基类中被声明为virtual，并在派生类中又一次定义的成员函数，可实现成员函数的动态覆盖（Override）
  3、抽象类
  包括纯虚函数的类称为抽象类。因为抽象类包括了未定义的纯虚函数，所以不能定义抽象类的对象。