利用C++模板,代替虚函数,实现类的静态多态性

转载 2017年01月03日 11:09:43

文章来源 http://www.cppblog.com/woaidongmao/archive/2008/05/22/50805.aspx

熟悉模板编程的朋友或许听到过这个技巧或者模式: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();
}

  这是一个最普通的多态例子,下面看看一个比较有意思的例子:
例子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)。很明显模板继承类有着普通类不可比拟的灵活性。

下面是这篇文章的重头戏了,也是本文的目的所在。
我们看到例子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;
}

哈哈,看class der是不是同样实现了多态??而且语义和虚函数一致。可以进一步提取downcast()部分到一个基类实现更普遍的写法。

后面我实现了一个动态继承的类der2,它同样提供了灵活的继承用法,可惜好像因编译器而定,在vc6环境下是不能通过编译的,而在g++下是ok的。

 下面我编写了一个性能测试例程来测试利用虚拟函数实现多态和模板实现多态的性能。代码如下

#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;
}

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

这是未优化版本的,结果显示这两种方法不相上下,虚函数还略优,~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

运行优化版本,性能优势一下体现出来了,模板实现是虚函数的十倍:

./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++语言内置的,在复杂度方面,应该首选虚函数,这里提供的这个方法只是作者在学习过程中的一个体会,模板的世界实在是太奇妙和高深了。

Item 35:考虑虚函数的其他替代设计 Effective C++笔记

Item 35: Consider alternatives to virtual functions. 比如你在开发一个游戏,每个角色都有一个healthValue()方法。很显然你应该把...
  • yangjvn
  • yangjvn
  • 2015年09月25日 11:23
  • 791

使用模板实现多态性

在C++中我们一般采用虚函数的方式实现函数的多态性,实现运行期绑定。实际上我们也可以用模板来实现函数的多态性,这在ATL中大量使用的,请看如下的代码:templatetypename T,typena...

C++ Templates:模板的多态威力

C++模板类的虚函数成员

C++模板类只有在被使用的时候才会被特化,同样其成员函数也是在被使用的时候才被实例化。但是虚函数成员例外,原因应该是在定义一个模板类类型的变量时(使用模板类),为了确定虚函数表的大小,就已经实例化了虚...

模板成员函数为什么不能是虚函数

《Thinking in C++》volume 2第五章有这么一句话: Member template functions cannot be declared virtual.Current com...
  • jcwKyl
  • jcwKyl
  • 2009年01月13日 20:59
  • 13900

C++静态多态CRTP

CRTP指的是Curiously Recurring Template Prattern,这是一种可以实现静态多态的惯用法。我们知道C++中,你不能将基类的虚函数定义为模板函数。这时你就可以考虑使用C...

关于C++虚函数,纯虚函数以及模板等重要概念的深入讨论(二)

C++中核心功能的一些深入认识,理清虚函数、纯虚函数、析构与虚析构函数,模板函数与模板类之间的关系;并探讨如何在软件开发的过程中的合理的利用这些结构,从而实现高内聚,低耦合的思想,并使软件具备更好的扩...

c++中的虚函数、虚基类、类模板

一、虚函数 首先要明白C++为什么要引进虚函数这个机制, 虚函数就是在基类中被关键字virtual说明,并在派生类中重新定义的函数。虚函数的作用是允许在派生类中重新定义与基类同名的函数,并且可以通过...
  • zyazky
  • zyazky
  • 2016年08月15日 14:17
  • 1445

模板多态

在C++中我们一般采用虚函数的方式实现函数的多态性,实现运行期绑定。 实际上我们也可以用模板来实现函数的多态性,这在ATL中大量使用的,请看如下的代码: template class Arr...

【C++模版之旅】静态多态(模版模拟多态)的讨论

说到面向对象特性之一“多态”,以我的水平已经说不出太多新意了。相信很多程序员代码K多了,做梦都在“多态中”运行着。常规的多态是C++语义内置支持的一种特性,通过虚函数可以实现这个特性,为了后面以示区别...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:利用C++模板,代替虚函数,实现类的静态多态性
举报原因:
原因补充:

(最多只允许输入30个字)