脚本语言实现的高性能和优雅的类型调度

Question

我正在实现一个脚本系统，其中值作为void*和一个指示类型的枚举传递。

enum class ValueType
{
    Bool,
    Float,
    Int,
    // many more types...
};

我需要一个用于实现 API 的工作流程，如下所示。 这些 API 必须尽可能高效（switch 语句而不是虚拟调用）。

void Print(ValueType type, void* value);
bool Equals(ValueType type, void* value1, void* value2);
// etc...

我会满足于我现在拥有的笨拙的解决方案，但考虑到我必须为不同的子系统生成特定的 API 集，这会更加麻烦。 任何想法将不胜感激。

当前解决方案（我正在使用的代码库中不允许使用 lambdas 和auto ，但我仍然有兴趣查看使用这些功能的解决方案）

// Per-type implementations
template <typename T>
class SubsystemFunctions
{
public:
    void Print(void* value)
    {
        std::cout << *static_cast<T*>(value) << std::endl;
    }

    bool Equals(void* value1, void* value2)
    {
        return *static_cast<T*>(value1) == *static_cast<T*>(value2);
    }
};

// API and gory dispatching details
class SubsystemAPI
{
public:
    static void Print(ValueType type, void* value)
    {
        DispatchOnType(type, PrintDispatcher(), value);
    }

    static bool Equals(ValueType type, void* value1, void* value2)
    {
        bool result;
        DispatchOnType(type, EqualsDispatcher(), value1, value2, &result);
        return result;
    }

private:
    struct PrintDispatcher
    {
        template <typename FunctionsT>
        void operator()(FunctionsT&& functions, void* value)
        {
            functions.Print(value);
        }
    };

    struct EqualsDispatcher
    {
        template <typename FunctionsT>
        void operator()(FunctionsT&& functions, void* value1, void* value2, bool* result)
        {
            *result = functions.Equals(value1, value2);
        }
    };

private:
    template <typename DispatcherT, typename... ArgsT>
    static void DispatchOnType(ValueType type, DispatcherT&& dispatcher, ArgsT&&... args)
    {
        switch (type)
        {
        case ValueType::Bool:
            dispatcher(SubsystemFunctions<bool>(), std::forward<ArgsT>(args)...);
            break;
        case ValueType::Float:
            dispatcher(SubsystemFunctions<float>(), std::forward<ArgsT>(args)...);
            break;
        case ValueType::Int:
            dispatcher(SubsystemFunctions<int>(), std::forward<ArgsT>(args)...);
            break;
        // etc...
        }
    }
};