带模板参数的 C++ 函数调度

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

我尝试解决这个问题需要有一个Dispatcher通过查找适当类型的函数的类static函数称为lookup()。执行实际工作的函数总是被调用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. 它需要一个新的函数模板重载lookup()为我们想要支持的每个新数量的函数模板参数编写go().
3. 使用起来既麻烦又混乱。

以下是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 的内容。

Since go是模板的依赖名称，您需要使用template消歧义器：

case a: return &FunctionWrapper<a>::template go<T>;
//                                  ^^^^^^^^
case b: return &FunctionWrapper<b>::template go<T>;
//                                  ^^^^^^^^

这告诉编译器解析范围解析运算符后面的内容（::) 作为模板的名称，后面的尖括号作为模板参数的分隔符。

为什么在 GCC 下构建失败，我该如何修复它？

因为 GCC 符合标准，并且执行两阶段名称查找 http://blog.llvm.org/2009/12/dreaded-two-phase-name-lookup.html，而 MSVC 将名称查找延迟到实例化时间，因此知道go是模板的名称。

在实例化之前，此信息不可用，因为不可能知道什么T是，并且主模板可以专门针对给定的T以便go不是成员函数模板的名称，而是数据成员的名称。

这就是说，我希望 MSVC 支持template不管怎样，添加它应该能让你的程序在 GCC/Clang/whatever-conforms-to-the-Standard 和 MSVC 上编译。