动多态和静多态

#include  "stdafx.h"
#include    
using namespace std; 
 
 /* 
 动多态：  通过虚函数实现的多态是绑定的和动态的：

 

1. 绑定的含义是：对于参与多态行为的类型，它们（具有多态行为）的接口是在公共基类的设计

 中就预先确定的（有时候也把绑定这个概念称为入侵的或者插入的）。
 2. 动态的含义是：接口的绑定是在运行期（动态）完成的。动多态的函数调用机制是执行期才能进行确定，所以它是动态的。
 

静多态 ： 通过模板机制实现的多态是非绑定的和静态的：

 1. 非绑定的含义是：对于参与多态行为的类型，它们的接口是没有预先确定的（有时也称这个概念为非入侵的或者非插入的）。
 2. 静态的含义是：接口的绑定是在编译期（静态）完成的。它不采用虚函数机制，所以所有调用在编译期就可确定，因此它是静态的。

 */




//编译期完成多态
template
void test(T  t)
{
t.fun(); //只需要对象实现fun函数即可
}


class  A
{
public:
 void  fun()
{
cout << "A  fun" << endl;
}
};
class  B
{
public:
void fun()
{
cout << "B  fun" << endl;
}
};






//------奇特的递归模板模式（Curiously Recurring Template Pattern，CRTP ）---------------- 
template
class   Base
{ 
public :


void interface()
{
  // 转换为子类指针，编译期将绑定至子类方法  
    static_cast(this)->fun1();
}


   void  interface2()
{
     // 编译期将绑定至子类方法  
    Derived::fun2();
} 


private: 
// 下面两个方法，默认实现可以存在，或者应该被继承子类的相同方法覆盖  
void  fun1()
{
cout << "Base  fun1" << endl;
}
static void  fun2()
{ 
cout << "Base  fun2" << endl;
}
};




//奇特的模板递归模式
class   Derived1 :  public Base
{
public:
// 这里子类不实现，将使用父类的默认实现  
   void fun1()
{
cout << "Derived1  fun1" << endl;
} 


// 此方法将覆盖父类的方法  
static   void     fun2()
{
cout << "Derived1  fun2" << endl;
}
};


class   Derived2 : public  Base
{
public:
// 此方法将覆盖父类的方法  
void  fun1()
{
cout << "Derived2  fun1" << endl;
}


// 这里子类不实现，将使用父类的默认实现  
    static void  fun2()
{
cout << "Derived2  fun2" << endl;
} 
};




int main()
{
A  a1;
B  b1;
test(a1);
test(b1);




//-----------------------------------


Base   *p=  new  Derived1   ;
p->interface();
p->interface2();


Base  b;
b.interface();
b.interface2();


Derived1  d;
d.interface();
d.interface2();




Base   *p2 = new  Derived2;
p2->interface();
p2->interface2();


Base  b2;
b2.interface();
b2.interface2();


Derived2  d2;
d2.interface();
d2.interface2();


}