带有模板参数的c++函数分派

我正在重构一个大型类——我们称之为Big——它有大量的复制粘贴代码。这种复制粘贴代码大部分存在于switch case中，只是涉及的类型最终不同。代码根据类的enum成员变量进行切换，该变量的值仅在运行时才知道。

我试图解决这个问题涉及到一个Dispatcher类，它通过一个名为lookup()的static函数查找适当类型的函数。执行实际工作的函数总是称为go()，并且必须在包装器类模板中定义(其唯一参数是当前打开的运行时enum值)。go()函数本身可以是模板函数，也可以不是。

下面是代码的一个精炼版本。我很抱歉篇幅太长，但这是我在不丢失重要背景的情况下尽可能短的了。

#include <cassert>
class Big
{
    public:
        enum RuntimeValue { a, b };
        Big(RuntimeValue rv) : _rv(rv) { }
        bool equals(int i1, int i2)
        {
            return Dispatcher<Equals, bool(int, int)>::lookup(_rv)(i1, i2);
        }
        template<typename T>
        bool isConvertibleTo(int i)
        {
            return Dispatcher<IsConvertibleTo, bool(int)>::lookup<T>(_rv)(i);
        }
    private:
        template<RuntimeValue RV>
        struct Equals
        {
            static bool go(int i1, int i2)
            {
                // Pretend that this is some complicated code that relies on RV
                // being a compile-time constant.
                return i1 == i2;
            }
        };
        template<RuntimeValue RV>
        struct IsConvertibleTo
        {
            template<typename T>
            static bool go(int i)
            {
                // Pretend that this is some complicated code that relies on RV
                // being a compile-time constant.
                return static_cast<T>(i) == i;
            }
        };
        template<template<RuntimeValue> class FunctionWrapper, typename Function>
        struct Dispatcher
        {
            static Function * lookup(RuntimeValue rv)
            {
                switch (rv)
                {
                    case a: return &FunctionWrapper<a>::go;
                    case b: return &FunctionWrapper<b>::go;
                    default: assert(false); return 0;
                }
            }
            template<typename T>
            static Function * lookup(RuntimeValue rv)
            {
                switch (rv)
                {
                    case a: return &FunctionWrapper<a>::go<T>;
                    case b: return &FunctionWrapper<b>::go<T>;
                    default: assert(false); return 0;
                }
            }
            // And so on as needed...
            template<typename T1, typename T2>
            static Function * lookup(RuntimeValue rv);
        };
        RuntimeValue _rv;
};
int main()
{
    Big big(Big::a);
    assert(big.equals(3, 3));
    assert(big.isConvertibleTo<char>(123));
}

除了:

1. 它在Visual c++ 9(2008)下构建和工作良好，但在GCC 4.8下，它会导致lookup()的函数模板过载编译错误。
2. 它要求为go()中我们想要支持的每个新数量的函数模板参数编写一个新的lookup()函数模板重载。
使用起来又麻烦又混乱。

下面是在GCC下发生的错误:

Big.cpp: In static member function 'static Function* Big::Dispatcher<FunctionWrapper, Function>::lookup(Big::RuntimeValue)':
Big.cpp(66,65) : error: expected primary-expression before '>' token
                         case a: return &FunctionWrapper<a>::go<T>;
                                                                 ^
Big.cpp(66,66) : error: expected primary-expression before ';' token
                         case a: return &FunctionWrapper<a>::go<T>;
                                                                  ^
Big.cpp(67,65) : error: expected primary-expression before '>' token
                         case b: return &FunctionWrapper<b>::go<T>;
                                                                 ^
Big.cpp(67,66) : error: expected primary-expression before ';' token
                         case b: return &FunctionWrapper<b>::go<T>;
                                                                  ^

我的问题是双重的:

1. 为什么在GCC下构建失败，我如何修复它?
2. 是否有更好的(即不那么麻烦和令人困惑的)方法来做到这一点?

代码必须在Visual c++ 9(2008)下编译，所以我不能使用任何特定于c++ 11的代码