***编译时多态还是运行时多态

     运行时的多态，比如C++用虚函数，或者比如有些语言支持委托。这样实际运行的代码是运行时决定的，这样必须要承担一定的开销：

1、间接调用。比如说虚表。
2、调用的函数编译期不能确定，所以不能展开。

这样性能上是有很大的损失的。如果这个调用出现在一个循环里，或者被其他地方频繁的调用，效率会有很大的差距。

其实有些时候，我们并不是真的需要真正的运行时多态，有时可能就是编译期的多态。

举例：

 class  ServerBase
   {
 public :
      virtual   void  Open()  =   0 ;
     virtual   ~ServerBase() {} ;
 } ;
 
 class  FtpServer
   {
 public :
      virtual   void  Open()
        {
          // 
     }
 } ;
 
 class  HttpServer
   {
 public :
      virtual   void  Open()
        {
          // 
     }
 } ;
然后你的程序里使用起来是这样的：

 ServerBase *  pServer  =   new  HttpServer();
 pServer->Open() ;
这样你做了个HttpServer。如果这里就是个具体应用，没有要求你运行期间能替换协议，那么这个设计明显有额外的开销。让我们先做几个例子来看看调用一个函数的开销。

例子：

 class  CPolymorphismBase
   {
 public :
      void  MemberFunction()
        {
         std::cout << " MemberFunction Base " ;
     }
 
      virtual   void  VirtualFunction()
        {
         std::cout << " VirtualFunction Base " ;
     }
 
     virtual  ~ CPolymorphismBase() {}
 } ;
 
 class  CPolymorphismDerived :  public  CPolymorphismBase
   {
 public :
      void  MemberFunction()
        {
         std::cout << " MemberFunction Derived " ;
     }
 
      virtual   void  VirtualFunction()
        {
         std::cout << " VirtualFunction Derived " ;
     }
 } ;

首先我们来看看普通的成员函数的开销是怎么样的。

     CPolymorphismDerived derivedObject;
     CPolymorphismDerived *  pDerivedObject  =   new  CPolymorphismDerived();
 
     derivedObject.MemberFunction();
     pDerivedObject -> MemberFunction();

运行一下，看到汇编内容如下：

     derivedObject.MemberFunction();
 00401034   mov         eax,dword ptr [__imp_std::cout (40204Ch)]
 00401039   push        offset  string   " MemberFunction Derived "  (40213Ch)
 0040103E  push        eax 
 0040103F  call        std:: operator <<< std::char_traits < char >   >  (401190h)
     pDerivedObject -> MemberFunction();
 00401044   mov         ecx,dword ptr [__imp_std::cout (40204Ch)]
 0040104A  push        offset  string   " MemberFunction Derived "  (40213Ch)
 0040104F  push        ecx 
 00401050   call        std:: operator <<< std::char_traits < char >   >  (401190h) 

可以看到，函数不但没有虚表的开销，而且已经在这里展开了，编译器替我们完成了inline优化，这样的效率当然是最高的。

然后我们来看虚函数。

     CPolymorphismDerived derivedObject;
     CPolymorphismDerived *  pDerivedObject  =   new  CPolymorphismDerived();
     CPolymorphismBase *  pDerivedObjectBasePoint  =  pDerivedObject;
 
     derivedObject.VirtualFunction();
     pDerivedObject -> VirtualFunction();
     pDerivedObjectBasePoint -> VirtualFunction();

运行一下，看到汇编内容如下：

     derivedObject.VirtualFunction();
 0040103B  mov         eax,dword ptr [__imp_std::cout (40204Ch)]
 00401040   push        offset  string   " VirtualFunction Derived "  (40213Ch)
 00401045   push        eax 
 00401046   call        std:: operator <<< std::char_traits < char >   >  (4011A0h)
     pDerivedObject -> VirtualFunction();
 0040104B  mov         edx,dword ptr [esi]
 0040104D  mov         eax,dword ptr [edx]
 0040104F  add         esp, 8 
 00401052   mov         ecx,esi
 00401054   call        eax 
     pDerivedObjectBasePoint -> VirtualFunction();
 00401056   mov         edx,dword ptr [esi]
 00401058   mov         eax,dword ptr [edx]
 0040105A  mov         ecx,esi
 0040105C  call        eax  

栈上分配出来的那个对象，虽然是虚函数，但是编译期是确定的，所以没有虚表的开销，函数也成功展开了。
堆上new出来的那个对象，就不走运了。不管是基类指针还是派生类指针去操作，都有虚表的开销，同时函数也无法展开。

这是什么意思呢？就是说即时一开始的例子改成这样也一样性能很低下

 // ServerBase* pServer = new HttpServer();     //  既然这样写性能低。。。
 HttpServer *  pServer  =   new  HttpServer();       //  那我换成这样写吧！！！
 pServer->Open() ;                             //  but，即使不用基类指针操作，效率也是一样低。

我们来总结一下吧

性能 栈上分配 堆分配 + 父类指针 堆分配 + 子类指针
普通成员函数 高 高 高
虚函数 高 低 低

下面切入正题。
要让用户使用起来性能得到保障，就只有用普通成员函数了。（你总不能强制用户必须使用栈对象吧？）

既然是普通成员函数，那也就没ServerBase什么事了。（既然不使用虚函数，那么一个基类的指针也就调用不到子类了，所以这里弄个基类没什么用了。）所以，代码修改如下了：

 class  FtpServer
   {
 public :
      void  Open()
        {
          // 
     }
 } ;
 
 class  HttpServer
   {
 public :
      void  Open()
        {
          // 
     }
 } ;

所以使用的时候就可以这么写了：

 typedef  HttpServer ServerBase;
 typedef  HttpServer Server;
 
 ServerBase *  pServer  =   new  Server();
 pServer->Open();
 // 

这样，就可以了，什么时候需要一个Ftp的版本了，就可以简单修改头两行代码，别的都不用改，这样就是一个FtpServer了：

 typedef  FtpServer ServerBase;
 typedef  FtpServer Server;
 
 ServerBase *  pServer  =   new  Server();
 pServer -> Open();
 // 

这里也可以用模板：

 template < class  T >
 class  App
   {
 public :
     typedef T ServerBase;
     typedef T Server;
 
     static void  main()
        {
         ServerBase *  pServer  =   new  Server();
         pServer->Open() ;
         //
     }
 } ;

App<FtpServer>::main();        //  这就是Ftp的
//App<HttpServer>::main();     //  这就是Http的

这就是编译期的多态，都用普通成员函数，使用到多态对象的类可以使用模板来简化多态时的修改（都用模板，然后在外部整体一个typedef就可以把所有需要多态的类都提纯出来，一个修改就可以让全程序得到效果）。

当然，并不是到这就结束了。。。你的HttpServer和FtpServer都改好了。。。但是你的BOSS过来和你说：兄弟，新需求，需要允许运行时修改协议，允许热配置。然后你就发现：坏了，二了，咱已经改成编译期多态的了。。。

这该怎么办呢？怎么让你设计的类既能配置成编译期多态而且不损效率，又能配置成运行时多态呢？

这里可以用个Adapter来做。

 template < class  T >
 class  Server_Adapter :  public  ServerBase
   {
 public :
     Server_Adapter()
        {
     }
 
      virtual   ~ Server_Adapter()
        {
     }
 
 
      virtual   void  Open()
        {
         m_server.Open();
     }
 
 private :
     T m_server;
 } ;

这样就OK了。使用者如果需要编译期多态，就像上一个例子那么用就可以了，性能没问题；如果需要运行期多态，那就这么写：

 typedef ServerBase ServerBaseObject;
 typedef Server_Adapter < HttpServer >  HttpServerObject;
 typedef Server_Adapter < FtpServer >   FtpServerObject;
 
 ServerBaseObject *  pServer  =  NULL;
 int  nServerType  =   ;  //  这里可以动态得到，从配置文件里头读啊什么的，反正都行，运行时随便改。
    
 switch (nServerType)
   {
 case   0 :
        {
         pServer  =   new  HttpServerObject();
     }
      break ;
 case   1 :
        {
         pServer  =   new  FtpServerObject();
     }
      break ;
 default :
      // 
      break ;
 }
 pServer -> Open();
 // 

这样就运行时多态了，一点毛病没有。和一开始的方案比，没有一丝性能损失。也许你要问了：这不是多包了一层么？调用Open的时候，要多一次函数调用呀？当然不会了。。。作为Adapter的T来说，编译期是确定的，所以内部的对象m_server作为一个栈对象，调用的函数是可以展开的。我们还是看一下具体的汇编代码：

     pServer-> Open();
 00401030   mov         eax,dword ptr [__imp_std::cout (402050h)]
 00401035   push        eax 
 00401036   call        std:: operator <<< std::char_traits < char >   >  (401190h)
 0040103B  pop         ecx  

可见，这里的代码展开了，您可以试验一下在HttpServer::Open和FtpServer::Open那里下个断点，就会发现根本断不下来，因为那里的代码已经展开在Server_Adapter<HttpServer>和 Server_Adapter<FtpServer>里头了，根本没有间接调用的问题。

这样，一个兼顾效率和灵活性的完美类库产生了。