撰写的std :: integral_constant值

Question

考虑以下代码

#include <iostream> 
#include <type_traits> 

enum Thing {Thing0, Thing1, Thing2, NumThings}; 
enum Object {Object0, Object1, Object2, NumObjects}; 

template <Thing> struct ThingValue; 

template <> struct ThingValue<Thing0> : std::integral_constant<int, 5> {}; 
template <> struct ThingValue<Thing1> : std::integral_constant<int, 2> {}; 
template <> struct ThingValue<Thing2> : std::integral_constant<int, 12> {}; 

template <Object> struct ObjectValue; 

template <> struct ObjectValue<Object0> : std::integral_constant<Thing, Thing2> {}; 
template <> struct ObjectValue<Object1> : std::integral_constant<Thing, Thing0> {}; 
template <> struct ObjectValue<Object2> : std::integral_constant<Thing, Thing1> {}; 

int main() { 
    std::cout << ThingValue<ObjectValue<Object0>::value>::value << '\n'; // 12 
} 

我试图定义，ComposeValues<T, Value, Pack...>因此，上述在main（）可以写成ComposeValues<Object, Object0, ThingValue, ObjectValue>::value。那么这可以扩展到任何数量的这样的组合物。这不是一件绝对重要的事情，但我认为定义这样的事情是一个很好的小练习。但我的语法有困难：

template <typename T, T Value, template <typename> class...> struct ComposeValues; 

template <typename T, T Value, template <typename> class First, template <typename> class... Rest> 
struct ComposeValues<T, Value, First, Rest...> { 
    static auto value = First<typename ComposeValues<T, Value, Rest...>::value>::value; 
}; 

template <typename T, T Value, template <T> class Last> 
struct ComposeValues<T, Value, Last> : std::integral_constant<T, Last<Value>::value> {}; // Won't compile. 

这是甚至可能我正在尝试做什么？

Answer 1

您遇到的问题是您不能混合使用不同非类型参数的模板模板。在您的示例中，这意味着ObjectValue和ThingValue无法绑定到template <typename> class...。

解决此问题的一种方法是将您的枚举编码为某种类型的模板，它可以不加区分地保存它们。一个可能的方法是将枚举视为int s，并让用户担心传入的合理类型。

首先，我们创建包装器当前的类型：

template <typename> struct ThingValueWrapper; 
template <int I> 
struct ThingValueWrapper<std::integral_constant<int,I>> 
    : ThingValue<static_cast<Thing>(I)> 
{}; 

template <typename> struct ObjectValueWrapper; 
template <int I> 
struct ObjectValueWrapper<std::integral_constant<int, I>> 
    : ObjectValue<static_cast<Object>(I)> 
{}; 

然后，我们可以做的非常相似，你原来有什么东西：

template <typename T, T Value, template <typename> class...> struct ComposeValues; 

template <typename T, T Value, 
      template <typename> class First, 
      template <typename> class... Rest> 
struct ComposeValues<T, Value, First, Rest...> 
    : std::integral_constant<int, 
          First<typename ComposeValues<T, Value, Rest...>::type>::value> 
{}; 

template <typename T, T Value> 
struct ComposeValues<T, Value> : std::integral_constant<int, static_cast<int>(Value)> {}; 

从原来的使用情况的唯一区别是我们需要使用我们的包装，而不是原始的枚举特性：

ComposeValues<Object, Object0, ThingValueWrapper, ObjectValueWrapper>::value