c++ - 在模板参数推导过程中可以转换吗？

Question

我在这里有此代码:

#pragma once
using uInt = size_t;

template<uInt id> class idType {};
template<typename T> class typeId {};

#define Generate_Type_To_ID_Mapping(id, t)                          \
class t;                                                            \
template<>class idType<id> { public: using type = t; };             \
template<>class typeId<t> { public: operator uInt() { return val; } \
    typeId() = default;                                             \
    typeId(typeId const&) = delete;                                 \
    typeId& operator=(typeId const&) = delete;                      \
    typeId(typeId&&) = delete;                                      \
    typeId& operator=(typeId&&) = delete;                           \
    static constexpr uInt val = id;                                 \
};

Generate_Type_To_ID_Mapping(0, Entity);
Generate_Type_To_ID_Mapping(1, RectComponent);
Generate_Type_To_ID_Mapping(2, ConstraintComponent);
Generate_Type_To_ID_Mapping(3, TextComponent);

这是一个宏，它为每个给定的 <size_t, T>集制造2个模板专业知识，一个模板执行从类型到索引的转换，另一个执行从索引到类型的转换。
他们这样称呼:

// type to index:
typeId<RectComponent>()  // the conversion operator returns 
                         // the value mapped to this type
// index to type:
idType<2>::type          // type is an alias to the mapped type

它们自己可以很好地工作，但是如果我尝试像 idType<typeId<RectComponent>()>::type这样将一个放入另一个内部，则代码将无法编译，而且我怀疑这是因为模板参数推导没有尝试任何转换( typeId<>()依赖 operator uInt())

我有某种方法可以做到，因此在模板参数推导过程中可以将 operator uInt()视为选项？

Answer 1

任何可以视为函数声明的内容，编译器都会将其解析为函数声明。这被称为most vexing parse。 typeId<RectComponent>()可以视为函数声明:无名函数，返回typeId<RectComponent>并接受参数。

这就是为什么idType<typeId<RectComponent>()>::type中出现错误的原因:编译器尝试使用函数类型作为模板参数实例化idType模板。

等效代码为:

using T = typeId<RectComponent>();    // this line is OK, T is a function type
using Type = idType<T>::type;         // error is here

该等效代码由于完全相同的原因而无法编译

using Type = idType<typeId<RectComponent>()>::type;

不编译。

您想要什么:

constexpr uInt id = typeId<RectComponent>();
using Type = idType<id>::type;

您可以添加额外的括号以避免歧义:

using Type = idType<(typeId<RectComponent>())>::type;

这是有效的，因为 (typeId<RectComponent>())不是有效的函数声明。

当然 operator uInt()应该标记为 constexpr:

constexpr operator uInt() { return val; }

参见 demo。