C＆＃x2B;＆＃x2B;使用枚举变量调度模板

Question

我的功能具有两个枚举变量的模板。有什么方法可以通过enuma和enumb的不同组合来派遣函数f？如果，我不想写太多。在这种情况下，我可能只需要编写4个分支，但是在实际情况下，我需要编写Tens分支。

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cassert>
using namespace std;

enum EnumA
{
    enumA0,
    enumA1
};
enum EnumB
{
    enumB0,
    enumB1
};

template <EnumA enumA, EnumB enumB>
void f()
{
    if (enumA == enumA0)
    {
        if (enumB == enumB0)
        {
            // something here
            return;
        }
        else if (enumB == enumB1)
        {
            // something here
            return;
        }
        else
        {
            assert(false);
        }
    }
    else if (enumA == enumA1)
    {
        if (enumB == enumB0)
        {
            // something here
            return;
        }
        else if (enumB == enumB1)
        {
            // something here
            return;
        }
        else
        {
            assert(false);
        }
    }
}

int main()
{
    int a, b;
    cin >> a >> b;
    const auto enumA = a < 0 ? enumA0 : enumA1;
    const auto enumB = b < 0 ? enumB0 : enumB1;
    f<enumA, enumB>(); // Is there a way to dispatch this with different enumA and enumB combinations?
    return 0;
}

Answer 1

如果您的主要关注点是避免重复的，如果/else或switch/case构造，则可以在Igor指出的那样创建一个查找表。

为此，您可以将功能（您的“这里”部分）分为单个功能，然后您的查找表将其检索。

因此，我们将从您的模板功能中删除分支。现在，这只是不确定组合的全部内容。

template <EnumA enumA, EnumB enumB>
void f() {
    assert(false);
}

为了根据组合指定应该发生的事情，我们可以专业化功能模板。

template <>
void f<enumA0, enumB0>() {
    // something here
    puts("0-0");
}
template <>
void f<enumA1, enumB0>() {
    // something here
    puts("1-0");
}
template <>
void f<enumA0, enumB1>() {
    // something here
    puts("0-1");
}
template <>
void f<enumA1, enumB1>() {
    // something here
    puts("1-1");
}

定义了应该发生的事情时，我们必须桥接的唯一差距是如何“转换”运行时已知的枚举值为非类型模板参数（又称编译时已知的枚举值），我们在函数定义中使用了。换句话说，我们如何从枚举值传递到一个函数（例如dispatch（enuma1，enumb0）到我们函数专业化的调用（例如f＆lt; enuma1，enumb0＆gt;

void dispatch(EnumA a, EnumB b){
static const std::map<std::pair<EnumA, EnumB>, void(*)()> lookup = {
    {{enumA0, enumB0}, &f<enumA0, enumB0>},
    {{enumA0, enumB1}, &f<enumA0, enumB1>},
    {{enumA1, enumB0}, &f<enumA1, enumB0>},
    {{enumA1, enumB1}, &f<enumA1, enumB1>},
};
    return lookup.at({a, b})();
}

>
现在，您的主要内容看起来像这样：

int main()
{
    int a, b;
    cin >> a >> b;
    const auto enumA = a < 0 ? enumA0 : enumA1;
    const auto enumB = b < 0 ? enumB0 : enumB1;
    dispatch(enumA, enumB);
    return 0;
}

caveats

• 它很好地解释了这个想法而不用优化的互机来解释。
• std :: Map绝对不是查找表的最适合的数据结构，但是在添加枚举值时， 您将必须在查找表中提供额外的功能专业和几个条目。 在沿着这条路线之前，这将很快变得笨拙
• ，建议您肯定要对您正在编写的组件的整体设计进行批判性的审查，并评估是否没有更简单的解决方案可以首先避免您的陈述问题改变设计。

奖励

在技术上可以自动创建查找表，从而大大减少向枚举添加更多值所需的工作量。但是，它不能解决组件中的任何设计缺陷，同时肯定会增加复杂性。

template <auto...>
struct EnumAsTypes {};
template <auto... Params>
consteval size_t Size(EnumAsTypes<Params...>) {
    return sizeof...(Params);
}
using ATypes = EnumAsTypes<enumA0, enumA1/*, enumA2*/>;
using BTypes = EnumAsTypes<enumB0, enumB1>;

void dispatch2(EnumA a, EnumB b) {
    static constinit auto lookup = []<EnumA... As, EnumB... Bs>(
                                       EnumAsTypes<As...> as,
                                       EnumAsTypes<Bs...> bs) {
        typedef void (*FunctionType)();
        std::array<FunctionType, Size(as) * Size(bs)> lookup;
        (([&]<EnumA InnerA>() {
             ((lookup[InnerA + sizeof...(As) * Bs] = f<InnerA, Bs>), ...);
         }.template operator()<As>()),
         ...);
        return lookup;
    }(ATypes{}, BTypes{});

    lookup[a + Size(ATypes{}) * b]();
}

您可以在编译器资源管理器这里