Modèles variadiques et instruction switch?
J'ai la fonction suivante qui peut prendre N arguments de types différents et les transmet à N fonctions basées sur chaque type individuel, de cette manière (exemple avec deux 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;
}
}
Je souhaite écrire cette fonction avec des modèles variadiques afin qu’elle puisse gérer n’importe quel nombre d’arguments de manière sécurisée. Je peux voir une solution utilisant des fonctions récursives, en passant le compteur et l'index variadique et en les comparant pour égalité, mais cela semblerait produire un code bien moins efficace que l'instruction switch ci-dessus (une séquence de contrôles if comparés à une table de saut ).
Cela peut-il être fait efficacement en utilisant une métaprogrammation de modèles ou dois-je fournir des surcharges pour chaque arité?
Voici une solution similaire à celle de max, mais elle: a) sépare clairement les parties génériques des parties spécifiques à la solution, et b) je montre que clang l’optimise pleinement. L'idée de base est de construire un cas de commutation lors de la compilation, à partir d'une séquence entière contiguë. Nous faisons cela comme ça:
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;
}
L'idée est que l'entier est transmis au lambda en tant que type de constante intégrale, donc utilisable dans les contextes de compilation. Pour utiliser cela avec le problème actuel, tout ce que nous avons à faire est d’envoyer un tuple au pack variadique et d’appliquer les astuces habituelles avec la séquence d’index:
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...>{});
}
Nous utiliserons cette définition de func2 pour examiner un assemblage:
template <class T>
bool func2(const T& t) { std::cerr << t; return std::is_trivial<T>::value; }
En regardant ici: https://godbolt.org/g/6idVPS nous remarquons les instructions suivantes:
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]
En cherchant cette étiquette, on trouve:
.LJTI2_0:
.quad .LBB2_2
.quad .LBB2_4
.quad .LBB2_5
.quad .LBB2_6
.quad .LBB2_7
.quad .LBB2_10
En d'autres termes, clang a converti cela en une table de saut, et en ligne tous les appels à func2. Ce n'est pas possible en utilisant une table de pointeurs de fonction comme certains l'ont suggéré (du moins je n'ai jamais vu un compilateur le faire), en fait, le seul moyen d'obtenir cette assemblée est via switch case, ou avec cette technique + clang. Malheureusement, gcc ne générera pas une assemblée aussi bonne, mais restera décente.
Juste pour le plaisir, je propose la voie suivante
template <typename ... Ts>
bool func (int & cnt, Ts ... xs)
{
using unused = int[];
int i { -1 };
bool ret { true };
(void)unused { 0, ((++i == cnt ? (ret = func<Ts>(xs)) : true), 0)... };
if ( ret && (cnt <= i) )
++cnt;
return ret;
}
mais je ne pense pas que ce soit un moyen efficace d’intervertir.
Cette solution peut être la plus efficace:
template<size_t I,class...Args>
bool func2_b(Args...arg)
{
if (func2(std::get<I>(std::Tuple<Args...>{arg...})))
return true;
else
return false;
}
template<class...Args,size_t...Is>
bool func_(int& counter,std::index_sequence<Is...>,Args...args)
{
using ft = bool(*)(Args...);
ft table[]={func2_b<Is,Args...>...};
if (counter<0 || counter>=(int)sizeof...(Args))
return false;
return table[counter](args...);
}
template<class...Args>
bool func(int& counter,Args...xs)
{
return func_(counter,std::make_index_sequence<sizeof...(Args)>{},xs...);
}
Aussi pour le plaisir, cela pourrait être un peu trop compliqué
#include<type_traits>
#include<array>
template<typename T>
void g(T&& t)
{
// This function gets called
}
template<typename T>
void entry(void* p)
{
g(*(std::remove_reference_t<T>*)p);
}
template<size_t N>
using table_t = std::array<void (*)(void*), N>;
template<typename... Ts>
constexpr auto make_table()
{
return table_t<sizeof...(Ts)>{
entry<Ts>...
};
}
template<size_t N>
void f_(const table_t<N>&, int)
{
}
template<size_t N, typename T, typename... Ts>
void f_(const table_t<N>& table, int select, T&& t, Ts&&... ts)
{
if(select == N - sizeof...(Ts) - 1)
table[select]((void*)&t);
else
f_(table, select, std::forward<Ts>(ts)...);
}
template<typename... Ts>
void f(int select, Ts&&... ts)
{
static constexpr auto table = make_table<Ts...>();
if(select < 0 || select >= int(sizeof...(Ts)))
throw "out of bounds";
f_(table, select, std::forward<Ts>(ts)...);
}
Ce qui lance une table dans f et envoie en conséquence g.
Théoriquement, vous pouvez effectuer une recherche binaire d'index de paramètre par vous-même:
#include <type_traits>
#include <Tuple>
#include <typeinfo>
#include <iostream>
#include <algorithm>
template <std::size_t I>
using ic = std::integral_constant<std::size_t, I>;
template <class T>
bool func2(T) {
std::cout<<typeid(T).name()<<std::endl;
return true;
}
template <std::size_t N, class T>
bool func_impl(ic<0>, ic<N>, std::size_t &, T &&tup) {
constexpr int index = std::min(N - 1, std::Tuple_size<T>{} - 1);
if (func2<std::Tuple_element_t<index, std::decay_t<T>>>(std::get<index>(tup)))
return true;
return false;
}
template <std::size_t K, std::size_t N, class T>
bool func_impl(ic<K>, ic<N> n, std::size_t &counter, T &&tup) {
if (counter == N - 1) {
return func_impl(ic<0>{}, n, counter, std::forward<T>(tup));
}
if (counter < N) {
return func_impl(ic<K/2>{}, ic<N - K>{}, counter, std::forward<T>(tup));
} else {
return func_impl(ic<K/2>{}, ic<N + K>{}, counter, std::forward<T>(tup));
}
}
template <class... Ts>
bool func(std::size_t& counter, Ts&&... xs) {
return func_impl(ic<sizeof...(Ts)/2>{}, ic<sizeof...(Ts)/2>{}, counter, std::forward_as_Tuple(xs...));
}
int main() {
std::size_t i = 0;
func<int, float, double, char>(i, 1, 2, 3, 4);
}