编译的代码片段std=c++17作为唯一的编译器标志...

• ...使用 GCC 9.1 成功编译。Godbolt https://godbolt.org/z/QKJomx
• ...使用 Clang 8.0.0 发出编译器错误（代码片段下方的错误）。Godbolt https://godbolt.org/z/S7tB5K

问题：这是 Clang 编译器中的错误，还是 GCC 接受此代码的错误，还是有其他原因？

#include <functional>
#include <tuple>

template <typename... Ts>
struct Foo
{
    template <typename T>
    using Int = int;

    // Function that accepts as many 'int' as there are template parameters
    using Function = std::function< void(Int<Ts>...) >;

    // Tuple of as many 'int' as there are template parameters
    using Tuple = std::tuple< Int<Ts>... >;

    auto bar(Function f)
    {
        std::apply(f, Tuple{}); // Error with Clang 8.0.0
    }
};

int main()
{
    auto foo = Foo<char, bool, double>{};
    foo.bar([](int, int, int){});
}

令我感到奇怪的是，Clang 的错误表明它已成功别名Tuple as std::tuple<int, int, int>但它错误地别名Function就这样std::function<void(int)>，只有一个而不是三个参数。

In file included from <source>:2:
In file included from /opt/compiler-explorer/gcc-8.3.0/lib/gcc/x86_64-linux-gnu/8.3.0/../../../../include/c++/8.3.0/functional:54:
/opt/compiler-explorer/gcc-8.3.0/lib/gcc/x86_64-linux-gnu/8.3.0/../../../../include/c++/8.3.0/tuple:1678:14: error: no matching function for call to '__invoke'
      return std::__invoke(std::forward<_Fn>(__f),
             ^~~~~~~~~~~~~
/opt/compiler-explorer/gcc-8.3.0/lib/gcc/x86_64-linux-gnu/8.3.0/../../../../include/c++/8.3.0/tuple:1687:19: note: in instantiation of function template specialization 'std::__apply_impl<std::function<void (int)> &, std::tuple<int, int, int>, 0, 1, 2>' requested here
      return std::__apply_impl(std::forward<_Fn>(__f),
                  ^
<source>:19:14: note: in instantiation of function template specialization 'std::apply<std::function<void (int)> &, std::tuple<int, int, int> >' requested here
        std::apply(f, Tuple{}); // Error
             ^
<source>:26:9: note: in instantiation of member function 'Foo<char, bool, double>::bar' requested here
    foo.bar([](int, int, int){});

额外的研究

正如评论中的其他用户已经指出的那样，Int模板别名取决于类型T修复问题：

template <typename T>
using Int = std::conditional_t<true, int, T>;

我还发现了其他一些事情，只是参考Function从外部输入也可以使其按预期/期望工作：

int main()
{
    auto f = Foo<char, bool, double>::Function{};
    f = [](int, int, int){};
}

TL;DR：这是一个 clang bug，但标准中也存在一个 bug。

首先要注意，在 C++ 中，模板分两步处理：

1. 不存在的构造依赖的模板上的参数是在定义封闭模板时构建的。
2. 依赖的构造是在实例化封闭模板时构建的。

现在看来 clang 对待std::function< void(Int<Ts>...) >作为非依赖类型，推理如下：

1. Int<Ts>是非依赖类型（正确）。
2. 因此，包扩展包含Int<Ts> (i.e. Int<Ts>...）也是一个非依赖的“类型”（？）。
3. 因为所有组件void(Int<Ts>...)是非依赖的，它是非依赖类型（显然不正确）。
4. 因为名字std::function是非依赖的并且模板参数void(Int<Ts>...)是一种非依赖非包扩展类型，std::function< void(Int<Ts>...) >是非依赖类型。

（请注意，“非包扩展”检查使其与Tuple case.)

因此，当Foo已定义，类型名称Function被视为命名非依赖类型，并立即构建，并且不考虑包扩展（在实例化期间发生）。因此，所有使用Function被“脱糖”类型取代std::function< void(int) >.

此外，clang 还有一个概念依赖于实例化，这意味着该构造是不依赖的，但它仍然以某种方式涉及模板参数（例如，该构造仅对某些参数有效）。std::function< void(Int<Ts>...) >被视为依赖于实例化的类型，因此当模板被实例化时，clang仍然执行替换using Function = std::function< void(Int<Ts>...) >。因此，Function获取正确的类型，但这不会传播到使用Function在定义中Foo.

现在这是标准中的错误。

类型是否依赖定义在[温度相关类型] http://eel.is/c++draft/temp.dep.type#9:

一个类型是依赖的，如果它是

• 模板参数，
• 未知专业的成员，
• 作为当前实例化的依赖成员的嵌套类或枚举，
• 一个 cv 限定类型，其中 cv 不限定类型是从属的，
• 由任何依赖类型构造的复合类型，
• 其元素类型是相关的或其边界（如果有）是值相关的数组类型，
• 其异常规范与值相关的函数类型，
• 表示为简单模板 ID其中模板名称是模板参数，或者任何模板参数是依赖项 类型或依赖于类型或值的表达式或者是 包扩展[ 注意：这包括一个注入类名 没有使用类模板模板参数列表。 — 尾注 ]，或
• 表示为decltype(expression)，其中表达式取决于类型。

请注意，它并没有说参数列表包含包扩展的函数类型是依赖类型，只是说“从任何依赖类型构造的复合类型”和“异常规范依赖于值的函数类型”是依赖的。两者在这里都没有帮助。