面向对象编程---多态性

#include "iostream"
using namespace::std;
class B0
{
public :
    virtual void display()
    {cout << "B0::display()"<<endl;}
};
                                                                                                                                                                                                                                                                                                                                                                                    
class B1:public B0
{
public :
    void display()
    {
        cout<< "B1::display()"<<endl;
    }
};
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    
class D1:public B1
{
                                                                                                                                                                                                                                                                                                                                                                                    
public :
    void display()
    {
        cout << "D1::display()" <<endl;
    }
};
                                                                                                                                                                                                                                                                                                                                                                                    
void fun(B1 *ptr)
{
    ptr->display();
}
                                                                                                                                                                                                                                                                                                                                                                                    
int main()
{
/*  B0 b0,*p;
    B1 b1;
    D1 d1;
    p=&b0;
    fun(p);
    p=&b1;
    fun(p);*/
    B1 b1,*p;
    p=&b1;
    fun(p);
                                                                                                                                                                                                                                                                                                                                                                                    
    D1 d1;
    p=&d1;
    fun(p);
    return 0;
}

输出：

B1::display()

D1::display()

示例3：

＃include <iostream>
using namespace std;
class B0 //基类B0声明
{public: //外部接口
 virtual void display() //虚成员函数
     {cout<<"B0::display()"<<endl;}
};
class B1: public B0 //公有派生
{ public:
       void display()  {  cout<<"B1::display()"<<endl;  }
};
class D1: public B1 //公有派生
{ public:
   void display() {  cout<<"D1::display()"<<endl;  }
};
void fun(B0 *ptr) //普通函数
{    ptr->display();    }
void main() //主函数
{ B0 b0,  *p; //声明基类对象和指针
 B1 b1; //声明派生类对象
 D1 d1; //声明派生类对象
 p=&b0;
 fun(p); //调用基类B0函数成员
 p=&b1;
 fun(p); //调用派生类B1函数成员
 p=&d1;
 fun(p); //调用派生类D1函数成员
}

输出：

B0::display()

B1::display()

D1::display()

从两个示例可以看出，虽然fun()的实参传递不同的参数，但还是根据自己的传递来进行传值。不要在乎刚开始声明fun()时所传递的函数为何值（基类还是派生类），这里都表示是一个基类引用。(我的理解fun()无论传递的基类还是派生类，都保留基类)

这其中涉及到一个规则：用基类的指针指向不同的派生类的对象时，基类指针调用其虚成员函数，则会调用其真正指向对象的成员函数，而不是基类中定义的成员函数（只要派生类改写了该成员函数）。若不是虚函数，则不管基类指针指向的哪个派生类对象，调用时都

会调用基类中定义的那个函数。
基于规则的例子：

＃i nclude <iostream>
using namecpace std;
class B0 //基类B0声明
{ public:
 void display(){cout<<"B0::display()"<<endl;} //公有成员函数
};
class B1: public B0 
{
 public:
 void display(){cout<<"B1::display()"<<endl;} 
};
class D1: public B1 
{
public:
 void display(){cout<<"D1::display()"<<endl;} 
};
void fun(B0 *ptr) 
{ ptr->display(); //"对象指针->成员名"  }
void main() //主函数
{ B0 b0; //声明B0类对象
 B1 b1; //声明B1类对象
 D1 d1; //声明D1类对象
 B0 *p; //声明B0类指针
 p=&b0; //B0类指针指向B0类对象
 fun(p);
 p=&b1; //B0类指针指向B1类对象
 fun(p);
 p=&d1; //B0类指针指向D1类对象
 fun(p);
}
运行结果：
B0::display()
B0::display()
B0::display()

虚函数是动态绑定的基础。

是非静态的成员函数。

在类的声明中，在函数原型之前写virtual。

virtual只用来说明类声明中的原型，不能用在函数实现时。

具有继承性，基类中声明了虚函数，派生类中无论是否说明，同原型函数都自动为虚函数。

本质：不是重载声明而是覆盖。

调用方式：通过基类指针或引用，执行时会根据指针指向的对象的类，决定调用哪个函数。（参考最后一个例子）

参考：http://www.cnblogs.com/kyleada/archive/2011/05/19/2051184.html