如何基于另一个模板参数将模板参数固定为一个枚举类？

Question

我有以下代码，到目前为止，我们有衣服和鞋类。但是将来可能会有更多的项目对象类型。 Foo 类是用 Object 模板化的，这里的成员函数对于 eClothes 和 eFootwear 是相同的，但在实际代码中会进一步模板化。

有没有办法对方法 order 的实现进行重复数据删除？由于存在一对一的映射

• Object::clothes -> eClothes
• Object::footwear -> eFootwear

.. 有没有什么技术可以用来修复基于type 的order 的模板参数？这样一个类实例化只接受其对应类型的命令，否则它是一个编译时错误？

#include<iostream>

enum class Object{
    clothes,
    footwear,
};
enum class eClothes{
    shirt,
};
enum class eFootwear{
    flipflop,
};

template <Object type>
class Foo{
    public:
    template<eClothes clothkind>
    void order(){
        std::cout << "hey\n";
    }

    template<eFootwear footwearkind>
    void order(){
        std::cout << "hey\n";
    }
};

int main(){
    Foo<Object::clothes> foo_clothes;
    Foo<Object::footwear> foo_footwear;
    foo_clothes.order<eClothes::shirt>();
    foo_footwear.order<eFootwear::flipflop>();
}

Answer 1

定义将Object 映射到其值类型的traits。喜欢：

template <Object value> struct ObjectTraits;
template <> struct ObjectTraits<Object::clothes>
{
    using type = eClothes;
};
template <> struct ObjectTraits<Object::footwear>
{
    using type = eFootwear;
};

template <Object type>
class Foo{
public:
    using Kind = typename ObjectTraits<type>::type;
    template<Kind kind>
    void order(){
        std::cout << "hey\n";
    }
};

为了简化一点 - 你可以使用宏：

template <Object value> struct ObjectTraits;
#define OBJECT_TRAITS(value, kind) \
template <> struct ObjectTraits<Object::value> { \
    using type = kind; \
}

OBJECT_TRAITS(clothes , eClothes);
OBJECT_TRAITS(footwear, eFootwear);