可变参数模板和switch语句？ [英] Variadic templates and switch statement?
问题描述
我有以下函数，它可以采用N个不同类型的参数，并以这种方式将它们转发给在每种类型上模板化的N个函数（带有两个参数的示例）：
I have the following function which can take N arguments of different types, and forwards them to N functions templated on each individual type, in this manner (example with two arguments):
template <typename T1, typename T2>
bool func(int& counter, T1 x1, T2 x2) {
switch (counter) {
case 0:
if (func2<T1>(x1)) {
counter++;
return true;
} else {
return false;
}
case 1:
if (func2<T2>(x2)) {
counter++;
return true;
} else {
return false;
}
default:
return true;
}
}
我想用可变参数模板编写此函数，以便它可以以类型安全的方式处理任意数量的参数。我可以看到使用递归函数的解决方案，传递计数器和可变参数索引并比较它们的相等性，但这似乎比上面的switch语句产生效率低得多的代码（与跳转表相比，一系列if-checks） ）。
I want to write this function with variadic templates so that it can handle any number of arguments in a type-safe way. I can see a solution using recursive functions, passing along the counter and the variadic index and comparing them for equality, but this would seem to yield far less efficient code than the switch statement above (a sequence of if-checks compared to a jump table).
可以使用模板元编程有效地完成此操作，还是需要为每个Arity提供重载？
Can this be done efficiently using template metaprogramming or do I need to provide overloads for each arity?
推荐答案
这是与max相似的解决方案，但它：a）清楚地将通用部分与解决方案特定的部分分开，并且b）我证明clang对其进行了完全优化。基本思想是在编译时根据连续的整数序列构建切换条件。我们这样做是这样的：
Here's a solution similar to max's, but it: a) clearly separates out the generic parts from the parts specific to the solution, and b) I show that clang fully optimizes it. The basic idea is to build a switch case at compile time, from a contiguous integer sequence. We do that like this:
template <class T, T ... Is, class F>
auto compile_switch(T i, std::integer_sequence<T, Is...>, F f) {
using return_type = std::common_type_t<decltype(f(std::integral_constant<T, Is>{}))...>;
return_type ret;
std::initializer_list<int> ({(i == Is ? (ret = f(std::integral_constant<T, Is>{})),0 : 0)...});
return ret;
}
这个想法是将整数作为整数常量类型传递给lambda，因此它可用于编译时上下文。要将其用于当前问题，我们所要做的就是转发可变参数包一个元组，并应用带有索引序列的常用技巧：
The idea is that integer gets passed into the lambda as an integral constant type, so its usable in compile time contexts. To use this with the current problem, all we have to do is forward the variadic pack a tuple, and apply the usual tricks with index sequence:
template <class T, std::size_t ... Is>
bool func_impl(std::size_t& counter, T&& t, std::index_sequence<Is...> is) {
auto b = compile_switch(counter, is, [&] (auto i) -> bool {
return func2(std::get<i>(std::move(t)));
});
if (b) ++counter;
return b;
}
template <class ... Ts>
bool func(std::size_t & counter, Ts&& ... ts) {
return func_impl(counter,
std::forward_as_tuple(std::forward<Ts>(ts)...),
std::index_sequence_for<Ts...>{});
}
我们将使用 func2的定义来查看某个程序集：
We'll use this definition of func2 to look at some assembly:
template <class T>
bool func2(const T& t) { std::cerr << t; return std::is_trivial<T>::value; }
在这里查看： https://godbolt.org/g/6idVPS 我们注意到以下说明：
Looking here: https://godbolt.org/g/6idVPS we notice the following instructions:
auto compile_switch<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul, bool func_impl<std::tuple<int&, double&, int&, unsigned long&, char const*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&>, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul>(unsigned long&, std::tuple<int&, double&, int&, unsigned long&, char const*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&>&&, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul>)::{lambda(auto:1)#1}>(unsigned long, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul>, bool func_impl<std::tuple<int&, double&, int&, unsigned long&, char const*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&>, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul>(unsigned long&, std::tuple<int&, double&, int&, unsigned long&, char const*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&>&&, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul>)::{lambda(auto:1)#1}): # @auto compile_switch<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul, bool func_impl<std::tuple<int&, double&, int&, unsigned long&, char const*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&>, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul>(unsigned long&, std::tuple<int&, double&, int&, unsigned long&, char const*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&>&&, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul>)::{lambda(auto:1)#1}>(unsigned long, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul>, bool func_impl<std::tuple<int&, double&, int&, unsigned long&, char const*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&>, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul>(unsigned long&, std::tuple<int&, double&, int&, unsigned long&, char const*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&>&&, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul, 5ul>)::{lambda(auto:1)#1})
push r14
push rbx
push rax
mov bl, 1
cmp rdi, 5
ja .LBB2_11
jmp qword ptr [8*rdi + .LJTI2_0]
查找该标签，我们发现：
Looking down for that label, we find:
.LJTI2_0:
.quad .LBB2_2
.quad .LBB2_4
.quad .LBB2_5
.quad .LBB2_6
.quad .LBB2_7
.quad .LBB2_10
换句话说，clang都将其转换为跳转表， 内联了对
In other words, clang has both turned this into a jump table, and inlined all the calls to func2. This is not possible using a table of function pointers as some have suggested (at least I've never seen a compiler do it), in fact the only way to get assembly this good is via switch case, or with this technique + clang. Sadly gcc will not generate assembly quite as good, but still decent.
这篇关于可变参数模板和switch语句？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
