为什么可变模板的模板特殊化不同于非可变模板的特殊化？

Question

我不明白为什么可变模板的模板专用化不同于常规（即非可变）模板。例如，我有一个模板和一个专门化，如：

enum class MF : int {
    ZERO = 0,
    ONE = 1,
    TWO = 2
};

// --------- Specialization -------------
template <MF mf>
class Stat{
public:
    Stat(std::string msg) {
        cout << "Generic Stat construtor: " << msg << endl;
    }
};

// --------- Template Specialization -------------
template<>
class Stat<MF::ONE>{
public:
    Stat(std::string msg) {
        cout << "Specialized Stat constructor: " << msg << endl;
    }
};

我专门研究 MF 枚举的特定值。

现在，如果我想专门化一个可变参数模板，我不能用 MF 枚举的特定值来专门化可变参数模板参数（例如，MF：：ONE），我只能专门化一个类型（例如 MF）。

// --------- Variadic Template -------------
template<MF mf, typename... E>
class Var{
public:
    Var(std::string msg){
        cout << "Generic Var constructor: " << msg << endl;
    }

};

// --------- Variadic Template Specialization -------------
template<>
class Var<MF::TWO, MF>{
public:
    Var(std::string msg){
        cout << "Specialized Var constructor: " << msg << endl;
    }
};

我想为一个特定的< code>MF值专门化我的变量模板，但是似乎我不能。

我是否遗漏了语言的某些方面，可以让我做我想做的事情？大致如下：

template<>
class Var<MF::TWO, MF::ONE>{
public:
    Var(std::string msg){
        cout << "Specialized Var constructor: " << msg << endl;
    }
};

完整的示例可以在这里找到

Answer 1

模板s不是宏。typename…并不意味着“采用任意数量的逗号分隔字符串”。typename…表示“采用0种或更多类型”。

MF：：ONE 不是一个类型。

尝试传递< code>MF::ONE,其中< code >模板需要< code>typename...是错误的，因为< code >模板要求的是< code>typename而不是值。

您可以编写一个模板类，它接受0个或多个MFs。您可以编写一个接受零个或多个类型的模板类。您不能编写一个接受0个或多个MFs或类型的模板类。C不支持这一点。

如果必须通过类型传递值，则有 std：：integral_constant

template<MF mf, typename... E>
class Var;
template<>
class Var<MF::TWO, std::integral_constant<MF, MF::ONE>>{
public:
  Var(std::string msg){
    cout << "Specialized Var constructor: " << msg << endl;
  }
};

你会通过 Var 实例化它

您可以创建别名：

template<MF mf> using MF_t=std::integral_constant<MF, mf>;

要使您的代码看起来更好:

template<MF mf, typename... E>
class Var;
template<>
class Var<MF::TWO, MF_t<MF::ONE>>{
public:
  Var(std::string msg){
    cout << "Specialized Var constructor: " << msg << endl;
  }
};
int main() {
  Var<MF::TWO, MF_t<MF::ONE>> instance("hello");;
}

出于元编程目的，有时编写模板是一个明智的想法，因为总是采用类型，而不采用常量，当您需要将常量填充到如上所述的类型中时。然后模板

您可以使用：：value访问std:：integral_content的值，或者通过构造它并将其转换为该类型的值。（在C 1y和许多C 11编译器中，这种转换是constexpr）。

那又怎样？

 MF x = MF_t<MF::ONE>{};
 MF y = MF_t<MF::ONE>::value;

将x和y设置为MF:：ONE。在这两种情况下，右边应该是编译时表达式，因此：

MF_t< MF_t<MF::ONE>{} >

是与MF_t相同的有效类型（如果写得很愚蠢）

Answer 2

如果我理解正确，您希望您的可变参数模板使用任意数量的MF值进行参数化。好吧，不要这样声明：

template<MF mf, typename... E>

…它声明了任意数量的类型参数，但如下所示：

template<MF mf, MF... moreMF>

...它声明任意数量的< code>MF类型的非类型参数。

也就是说，显式专业化对于不同的模板没有什么不同，但你不知怎么忘记了如何在两者之间进行参数化。