操作C++模板，取代虚函数实现类的静态多态性

副标题#e#

熟悉模板编程的伴侣或者听到过这个能力可能模式：Barton-Nackmann 能力可能称奇异轮回模板模式（Curiously Recurring Template Prattern）。

其实在《c++ 编程语言》这本bible 书里，在模板那章提到过一个很奇妙的类的实现，用的就是这个技能。其时，我就被C++模板技能叹为观止。近期在学boost库时偶尔遇到了这个能力，同时在写一个类时激发了我的思考，这里就操作这个能力来实现，静态多态函数（我本身发现的叫法，呵呵）。

我们知道C++的多态函数会带来许多机动性，可是不行制止的它是有运行时的性能损失的。而c++的另一个强大特性就是模板了。模板给C++带来了，编译时的多态，通过模板元编程，C++可以实现雷同C#，java的refection的特性。这里我就举来实现操作模板来代替虚函数。

例子1：

#include <iostream> using namespace std;

class common_base
{
public:
　 virtual void fun（）=0；
};
class common_derive:public common_base
{
public:
　 void fun（）
　 { cout<<"in common_derive fun()"<<endl;
};

void main()
{
　 common_base * pb = new common_derive;
　 pb->fun();
}

#p#副标题#e#

这是一个最普通的多态例子，下面看看一个较量有意思的例子：

例子2：

template<typename T> class class1 { public: 　　　 class1(T t):m_val(t){} 　　　 virtual T getVal(){ 　　　　　　　 cout<<"in class1,val =="<< m_val <<endl; 　　　　　　　 return m_val; 　　　 } private: 　　　 T m_val; };

class derived: public class1<int>
{
public:
　　　 derived(int i):class1<int>(i){}
　　　 int getVal()
　　　 {
　　　　　　　 cout<<"in derived"<<endl;
　　　　　　　 return class1<int>::getVal();
　　　 }
};

template<typename T>
class derived2: public class1<T>
{
public:
　　　 derived2(T val):class1<T>(val){}
　　　 T getVal()
　　　 {
　　　　　　　 cout<<"in derived2"<<endl;
　　　　　　　 return class1<T>::getVal();
　　　 }
};

void main()
{
　　　 class1<int> * pbase = new derived(10);
　　　 pbase->getVal();

　　　 class1<int> * pb2 = new derived2<int>(10);
　　　 pb2->getVal();
}

这个例子我的用意是说明：模板类的虚函数多态，并且派生类可以有两种选择，一个实现为普通类，担任的是模板基类的特化类，一个就实现模板类（如 derived2）。很明明模板担任类有着普通类不行相比的机动性。

下面是这篇文章的重头戏了，也是本文的目标地址。

#p#副标题#e#

我们看到例子1，2都回收虚函数来实现多态，这个是一般选择，如何用模板来实现多态，而不是虚函数呢？

看这个例子：

template<class derive> class base { public: 　　　 void print() 　　　 { 　　　　　　　 derive::print(); 　　　 } 　　　 void m_print() 　　　 { 　　　　　　　 downcast()->derive::m_print(); 　　　 } protected: 　　　 inline derive * downcast() 　　　 { 　　　　　　　 return static_cast<derive *>(this); 　　　 }; 　　　 inline const derive * downcast()const 　　　 { 　　　　　　　 return static_cast<const derive *>(this); 　　　 }; };

class der:public base<der>
{
public:
　　　 der(int foo):_foo(foo){}
　　　 static void print()
　　　 {
　　　　　　　 cout<<"in der print"<<endl;
　　　 };
　　　 void m_print()
　　　 {
　　　　　　　 cout<<"in der member fun m_print"<<endl;
　　　　　　　 cout<<"has member foo="<<_foo<<endl;
　　　 }
private:
　　　 int _foo;
};

template<class base>
class der2:public base
{
public:
　　　 static void print()
　　　 {
　　　　　　　 cout<<"in der2 print"<<endl;
　　　 };
　　　 void m_print()
　　　 {
　　　　　　　 cout<<"in der2 member fun m_print"<<endl;
　　　 }
};

class tmpclass
{
public:
　　　 void test()
　　　 { cout<<"in test"<<endl;}
};

int main(int argc, char* argv[])
{
　　　 //模板实现虚函数多态
　　　 base<der> * pb= new der(100);
　　　 pb->print();
　　　 pb->m_print();

　　　 //动态担任
　　　 der2<tmpclass> d2;
　　　 d2.print();
　　　 d2.m_print();
　　　 d2.test();

　　　 return 0;
}

#p#副标题#e#

哈哈，看class der是不是同样实现了多态？？并且语义和虚函数一致。可以进一步提取downcast（）部门到一个基类实现更普遍的写法。

后头我实现了一个动态担任的类der2，它同样提供了机动的担任用法，惋惜仿佛因编译器而定，在 vc6情况下是不能通过编译的，而在g++下是ok的。

下面我编写了一本机能测试例程来测试操作虚拟函数实现多态和模板实现多态的机能。代码如下

#p#分页标题#e#

#include <iostream> using namespace std; #include <sys/time.h>

class common_base
{
public:
　　　 common_base(int iloop){_iloop=iloop;}
　　　 virtual void virtual_fun()=0;
　　　 void timesum_fun()
　　　 {
　　　　　　　 struct timeval begin,end;
　　　　　　　 gettimeofday(&begin, NULL);
　　　　　　　 for(int i=0;i<_iloop;i++)
　　　　　　　　　　　 virtual_fun();
　　　　　　　 gettimeofday(&end, NULL);
　　　　　　　 cout<< "using time :" << end.tv_sec-begin.tv_sec + (end.tv_usec - begin.tv_usec)/1000000.0<<"　 second"<<endl;
　　　 };
private:
　　　 int _iloop;
};
class common_derive:public common_base
{
public:
　　　 common_derive(int iloop):common_base(iloop){_foo=0;}
　　　 void virtual_fun()
　　　 {
　　　　　　　 ++_foo;
　　　　　　　 --_foo;
　　　 }
private:
　　　 int _foo;
};

template<class derive>
class base
{
public:
　　　 base(int iloop){_iloop=iloop;}
　　　 void timesum_fun()
　　　 {
　　　　　　　 struct timeval begin,end;
　　　　　　　 gettimeofday(&begin, NULL);
　　　　　　　 for(int i=0;i<_iloop;i++)
　　　　　　　　　　　 templ_fun();

　　　　　　　 gettimeofday(&end, NULL);
　　　　　　　 cout<< "using time :" << end.tv_sec-begin.tv_sec + (end.tv_usec - begin.tv_usec)/1000000.0<<"　 second"<<endl;
　　　 }
　　　 inline void templ_fun()
　　　 {
　　　　　　　 downcast()->derive::templ_fun();
　　　 }
protected:
　　　 inline derive * downcast()
　　　 {
　　　　　　　 return static_cast<derive *>(this);
　　　 };
　　　 inline const derive * downcast()const
　　　 {
　　　　　　　 return static_cast<const derive *>(this);
　　　 };
private:
　　　 int _iloop;
};

class der:public base<der>
{
public:
　　　 der(int iloop):base<der>(iloop){_foo=0;}
　　　 inline void templ_fun()
　　　 {
　　　　　　　 ++_foo;
　　　　　　　 --_foo;
　　　 }
private:
　　　 int _foo;
};

int main()
{
　 int loop=1000*1000*100;
　 common_base * pb = new common_derive(loop);
　 base<der> * ptempb= new der(loop);
　 for(int i =3;i-->0;)
　 {
　　　　　 cout<<"virtual function test: looptime="<<loop<<endl;
　　　　　 pb->timesum_fun();
　　　　　 cout<<"template function test: looptime="<<loop<<endl;
　　　　　 ptempb->timesum_fun();
　 }
　 delete pb;
　 delete ptempb;
　 return 0;
}

#p#副标题#e#

我编译了两个版本一个优化版本一个未优化版本，运行测试结果让我有点意外：

这是未优化版本的，功效显示这两种要领八两半斤，虚函数还略优，～O～

./cmp_test virtual function test: looptime=100000000 using time :1.03824　 second template function test: looptime=100000000 using time :1.63043　 second virtual function test: looptime=100000000 using time :1.03768　 second template function test: looptime=100000000 using time :1.62773　 second virtual function test: looptime=100000000 using time :1.63104　 second

运行优化版本，机能优势一下浮现出来了，模板实现是虚函数的十倍：

#p#分页标题#e#

./cmp_test_optimize virtual function test: looptime=100000000 using time :0.615542　 second template function test: looptime=100000000 using time :0.055584　 second virtual function test: looptime=100000000 using time :0.624778　 second template function test: looptime=100000000 using time :0.057419　 second virtual function test: looptime=100000000 using time :0.624977　 second template function test: looptime=100000000 using time :0.059442　 second

有点惊人是不是？这个不同就是因为虚函数是不行优化和内联的，而模板函数是可内联的，这本机能差别就很大，再次随着虚表的增大虚函数的挪用是有机能退化的，而这点对付模板函数来说是没有的，因为在编译时，这一切都是静态了。不外客观的说，虚函数多态是C++语言内置的，在巨大度方面，应该首选虚函数，这里提供的这个要领只是作者在进修进程中的一个别会，模板的世界实在是太奇妙和高妙了。

当前位置：以往代写 > C/C++ 教程 >操作C++模板，取代虚函数实现类的静态多态性