给定typename T和int N，下面的模板化值生成类型为的空函数指针
int (*) (T_0, ..., T_N)
虽然代码有效，但我不喜欢它用Temp引导助手污染命名空间——Temp是必需的，因为类型不能括在括号中。例如，以下内容均无效。
(int (*)((int))
((int (*)(int)))
(int (*)( (I,T)... ))
最后一个条目显示了我希望如何将T扩展到NT的列表中——这当然是无效的。这是一个技巧，使T依赖于I，但由于使用了逗号运算符，其值仅为T。
作为一种变通方法，我被迫创建一次性类型的Temp模板，以使T依赖于int，或者在本例中，依赖于I。它作为Temp<T,I>的用法是有效的，因为它没有将类型括在括号中。
但是，正如我所说，我想去掉Temp，因为它会污染命名空间。在下面的代码中，我重述了这个问题，并演示了一些尝试的解决方案，但遗憾的是，它们都失败了。为了记录在案，我认为template <typename T, int> using Temp = T;和template <... template<typename T1, int N1> typename Temp=T>之间应该允许等价。
后续：当我最初发布这个问题时，我不知道为什么不允许使用额外的括号，我仍然不确定为什么我的一些尝试失败了。例如：
decltype(w<T,N>())...
result_of<w<T,N>()>::type...
我看不到类型周围有括号！
#include <iostream>
#include <typeinfo>
// Problem, #1
// This is a one-shot helper than pollutes the namespace
template <typename T, int>
using Temp = T;
// Idea #1
// Make the one-shot helper actuall useful, where ... represents either
// type or non-type parameters.
// Result
// Not possible.
//template <typename T, ...>
//using Dependent = T;
// Idea #2
// Make the types dependent within the template declaration
// Result
// Probably not possible
//template <typename T, int N, template<typename T1, int N1> typename F=T>
// Idea #6
// Replace the lambda with a struct (not shown)
// Result
// Crashes gcc
template <typename T, int N>
auto a =
[]<size_t... I>
(std::index_sequence<I...>) {
// Problem #2
// Function type declaration won't parse with extra parentheses
//return (int (*)( (I,T)... ))nullptr;
// Idea #3
// Move the templated helper into the function
// Result
// Not possible
//template <typename T, int>
//using Temp = T;
// Idea #4
// Replace the templated helper with a templated lambda which *is*
// allowed inside functions.
// Result
// Still requires parentheses, still breaks function type declaration
//auto w = []<typename T1, int N1>() -> T1 {};
//return (int (*)( decltype(w<T,N>())... ));
// Idea #5
// result_of (which is a template) instead of decltype
// Result
// Doesn't work even without parentheses, not sure why
//return (int (*)( result_of<w<T,N>>... ));
//return (int (*)( result_of<w<T,N>()>::type... ));
// Idea #7
// Use std::function
// Result
// Can't get function pointer from std::function
// Idea #2 implementation
//using F<T,I> = T;
//return (int (*)( F<T,I>... ))nullptr;
// So far, only this works:
return (int (*)( Temp<T,I>... ))nullptr;
}
(std::make_index_sequence<N>{});
int main () {
auto b = a<int, 4>;
std::cout << typeid(b).name() << std::endl;
}
您可以用std::enable_if_t<(void(I), true), T>替换Temp<T,I>。
函数类型声明不会解析额外的括号
这确实有效！为什么？
类型不能用括号括起来。但是enable_if_t的第一个自变量是一个表达式而不是一个类型，所以( )在那里是允许的。
使用Boost.Mp11:这很容易
template <typename... Args>
using into_func = int(Args...);
template <typename T, size_t N>
using result = mp_apply<func_type, mp_repeat_c<mp_list<T>, N>>;
mp_repeat_c<mp_list<T>, N>为我们提供了带有N参数的mp_list<T, T, T, ..., T>，然后我们在此基础上提供了mp_applyinto_func，这将其转换为我们想要的函数类型。
至于为什么你的一些其他版本不起作用：
这个：
decltype(w<T,N>())...
其中：
auto w = []<typename T1, int N1>() -> T1 {};
你不是这样称呼lambda的。调用运算符是一个模板，但不能提供这样的模板参数。你必须写w.operator()<T, N>()。如果你这样做了，那可能会奏效。
或者你可以做：
auto w = [](size_t) -> T { };
然后使用decltype(w(N))...。
尽管最好写一些更接近有效lambda的东西，比如：
auto w = [](size_t) { return std::type_identity<T>{}; };
然后使用typename decltype(w(N))::type...
这种方法：
result_of<w<T,N>()>::type...
CCD_ 31与CCD_ 32一样使用，其中CCD_ 33是函数或函数对象类型。例如：
struct F { double operator()(int); };
result_of_t<F(int)>; // this is double
这里根本不是这样的——这只是对result_of的滥用。result_of也被弃用，取而代之的是invoke_result，它无论如何都不能与指定的lambda一起使用，因为它需要模板参数而不是函数参数。
我最后一次重写tho:
typename std::invoke_result_t<decltype(w), decltype(N)>::type...
请注意decltype(w)(因为您需要一个类型，而不是对象)和decltype(N)(同样，键入而不是值)。