#include "stdafx.h"
#include 　　
using namespace std;

//1. 只能通过基类对象的指针的引用才能实现虚函数的特性
//2. 只需在把基类的成员函数设为 virtual，其派生类的相应的函数也会自动变为虚函数
//3. 多态有个关键之处就是一切用指向基类的指针或引用来操作对象

class A{ 
public:
 virtual void fun1(){ cout<<"A::fun1"< };

// 当将基类的成员函数定义为虚函数后，虚特性在定义它的类和之后继承它的派生类中有效，
// 即使派生类在重写该函数时并没有将它声名为虚函数，它仍然是虚函数。
class B: public A{ 
public: 
 void fun1(){ cout<<"B::fun1"< }; 
 

class C
{
public:
 void fun2(){ cout<<"C::fun2"< }; 

class D: public C
{
public:
 virtual void fun2(){ cout<<"D::fun2"< };
// 虚函数特性只对自定义之后的派生类对象有效，而对之前的基类没有任何影
// 响
class E: public D 
{
public:
 void fun2(){ cout<<"E::fun2"< };

class F: public E
{
public:
  void fun2(){ cout<<"F::fun2"< };

int _tmain(int argc, _TCHAR* argv[])
{
 A a;
 B b;
 C c;
 D d;
 E e;
 F f;
 

A* p1 = &a;       
A* p2 = &b;                                 //p2  指向基类的指针 --->  派生类对象
 

cout <<"p1->fun1 () 的结果:";         //A::fun1 ()
p1->fun1();
 

cout <<"p2->fun1 () 的结果:";         //B::fun1 ()
p2->fun1();
 

A &ra = b;                                       // 基类的引用也可以实现虚函数多态
cout <<"A &ra fun1 () 的结果:";       //B::fun1 ()
ra.fun1();
 
// 虽然都是指向基类的指针，但是不管用，基类并没有声明为虚函数 

C* p3 = &d;
C* p4 = &e;
C* p5 = &f;

cout <<"p3->fun2 () 的结果:";         //C::fun2 ()
p3->fun2();
cout <<"p4->fun2 () 的结果:";         //C::fun2 ()
p4->fun2(); 

cout <<"p5->fun2 () 的结果:";         //C::fun2 ()
p5->fun2();
 

D* p6 = &e;
D* p7 = &f;                  // 指向基类的指针，管用了
E* p8 = &f;                  // 对 F 类来说，E 是基类，但是 E 继承于 D  已经有了影响

cout <<"p6->fun2 () 的结果:";         //E::fun2 ()
p6->fun2();
 

cout <<"p7->fun2 () 的结果:";         //F::fun2 ()
p7->fun2();
 

cout <<"p8->fun2 () 的结果:";         //F::fun2 ()
p8->fun2();
 

 cin.get();
 return 0;
}

工程实例中：
// 根据零售商创建 srv
CDataResolveSrv* CRemoteDataManage::CreateSrv(int nBrandID)
{
  CDataResolveSrv* pSrv = NULL;
  switch (nBrandID)
  {
 case retailbrand_bsd:
   pSrv = new CDataResolveBSDSrv;
   break;
 case retailbrand_abd:
  pSrv = new CDataResolveABDSrv;
  break;
 case retailbrand_yjs:
  pSrv = new CDataResolveYJSSrv;
  break;
   }
 return pSrv;
}