利用C++模板，代替虚函数实现类的静态多态性及动态继承

关注

转载最新推荐文章于 2026-03-04 00:50:14 发布 933 阅读 AI 写同款· GEO 优化 ›

C++模板元编程详细教程（之十一）《C++模板元编程详细教程》系列的第11篇，也是完结篇，主要介绍了visit的实现方法、C++的模板范式，以及一些Q&A和感悟阅读详情

转自：http://blog.youkuaiyun.com/nancy_m/article/details/8691681

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