这是“如果 e 是一个包，则获取模板名称，否则获取变量名称”是否有效？

Question

我尝试构建一个不需要 typename 或 template 的案例，但仍会根据给定名称 t 是否为函数来生成变量或模板参数包与否

template<typename T> struct A { template<int> static void f(int) { } }; 
template<typename...T> struct A<void(T...,...)> { static const int f = 0; }; 
template<typename> using type = int; 

template<typename T> void f(T t) { A<void(type<decltype(t)>...)>::f<0>(1); }

int main() {
   f(1);   
}

以上将参考static const int，并做一个对比。以下只是将T t 更改为一个包并使f 引用一个模板，但GCC 也不喜欢

template<typename ...T> void f(T ...t) { A<void(type<decltype(t)>...)>::f<0>(1); }

int main() {
   f(1, 2, 3);   
}

GCC 第一次抱怨

main.cpp:5:68: error: incomplete type 'A<void(type<decltype (t)>, ...)>' used in nested name specifier
 template<typename T> void f(T t) { A<void(type<decltype(t)>...)>::f<0>(1); }

第二个

 main.cpp:5:74: error: invalid operands of types '<unresolved overloaded function type>' and 'int' to binary 'operator<'
  template<typename ...T> void f(T ...t) { A<void(type<decltype(t)>...)>::f<0>(1); }

我有多个问题

• 以上代码是否根据语言工作，还是有错误？
• 由于 Clang 接受这两种变体但 GCC 拒绝，我想问什么编译器是正确的？

• 如果我删除了主模板的主体，那么对于 f(1, 2, 3) 的情况，Clang 会抱怨

  main.cpp:5:42: error: implicit instantiation of undefined template 'A<void (int)>'
  

  请注意，上面写着A<void (int) >，而我期望的是A<void (int, int, int)>。这种行为是如何发生的？这是我的代码中的错误 - 即它是错误的，还是 Clang 中的错误？我似乎记得一个关于扩展顺序与别名模板替换的缺陷报告，这是否相关，是否会使我的代码格式错误？

Answer 1

扩展参数包应该或确实使表达式类型依赖。不管扩展的东西是否依赖于类型。

如果没有，那么 C++ 的类型依赖规则中就会有一个漏洞，这将是标准中的缺陷。

所以A<void(type<decltype(t)>...)>::f 当t 是一个包时，无论你在void( 这里拉) 部分来解包t，都应该是一个依赖类型，并且template 是必需的如果是template，则在f 之前。

在t 不是包的情况下，有意 type<decltype(t)> 不依赖（参见http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1390），但标准可能会或可能不会在这一点上达成一致（我认为不是？）

如果编译器做了“委员会的意图”，那么当 t 不是一个包时：

A<void(type<decltype(t)>...)>::f<0>(1)

可能意味着

A<void(int...)>::f<0>(1)

这是

A<void(int, ...)>::f<0>(1)

如果f 是template（您的代码使它成为int，但我认为交换两者应该可以）这很好。但该标准目前显然不同意？

因此，如果实现了 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1390，那么您可以交换您的两个 A 专业化。 void(T...,...) 特化应该有一个template<int> void f(int)，T 特化应该有一个static const int。

现在在A<> 依赖于（取决于包的大小）的情况下，::f 是int 并且不需要template。在A<> 不依赖的情况下，::f 是template，但不需要消歧。

我们可以将type<decltype(t)>...替换为：

decltype(sizeof(decltype(t)*))...

并且sizeof(decltype(t)*) 是非依赖类型（它是std::size_t），decltype 给了我们std::size_t，... 被视为老派... arg。这意味着void(std::size_t...) 变为非依赖类型，因此A<void(std::size_t...)> 不依赖，因此::f 作为模板在依赖上下文中不是模板。

如果t 是具有一个元素的参数包

decltype(sizeof(decltype(t)*))...

变成

std::size_t

但在依赖上下文中（t 包中每个元素一个副本）。所以我们得到

A<void(std::size_t)>::f

假定是一个标量值，所以

A<void(std::size_t)>::f<0>(1)

变成一个表达式，计算结果为false。

（在原始问题的 cmets 中与 Johannes 讨论时产生的逻辑链）。

Answer 2

您的第二个案例格式不正确； A<void(type<decltype(t)>...)>::f<0>(1) 应该是

A<void(type<decltype(t)>...)>::template f<0>(1)
//                             ~~~~~~~~~

对于第一种情况，两个编译器的行为都不正确；这被认为足够令人困惑，以至于提出CWG 1520 来查询正确的行为；结论是应该在别名替换之前应用包扩展：

后一种解释（专业列表）是正确的解释；参数包不能替代任何东西，包括别名模板特化。 CWG 认为这在目前的措辞中已经足够清楚了。

这让人想起 CWG 1558（别名模板和 SFINAE），它是为 C++14 修复的，但根据上述内容，即使 C++11 编译器也有望得到正确的结果，因此 gcc 和clang 弄错了（尽管公平地说，它们在更简单的情况下确实表现正确，包括 CWG 1520 中的激励示例）。请注意，MSVC 直到最近才拥有a similar bug；它在 VS2015 中已修复。

您的代码（仅在第一种情况下）是正确的；但作为一种解决方法，您可以更改别名模板以使用和丢弃其模板参数，为两个编译器修复您的程序 - 当然这意味着您的 CWG 1390 漏洞利用将不再有效：

template<typename T> using type = decltype(((int(*)(T*))(0))(0)); // int

但是，我不认为您的 CWG 1390 技巧可以像介绍的那样工作，因为即使 type<decltype(t)>... 的扩展替换不依赖于 t... 的类型，它也是取决于他们的编号：

template<typename T> struct A { template<int> static void f(int) {} }; 
template<> struct A<void(int, int, int)> { static const int f = 0; }; 

正如 Yakk 所指出的，如果你交换成员函数模板和数据成员，它就可以工作，因为数据成员在依赖上下文中是可以的。