组成 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....

解决此问题的一种方法是在某种类型的模板中对您的枚举进行编码，该模板可以不加区别地容纳它们。一种可能的方法是将枚举视为 ints 并让用户担心传递合理的类型。

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

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

组成 std::integral_constant 个值

Composing std::integral_constant values

c++

templates

variadic

c++11