Transform Typliste mit Funktion zur Laufzeit

Question

Ich habe eine Typliste. Ich möchte ein Tupel mit den Ergebnissen des Aufrufs einer Funktion für jeden Typ in dieser Liste erstellen und diese dann als Argumente für einen anderen Funktor verwenden. So etwas wie folgt aus:

template<typename F> 
struct function_traits; 

template<typename T, typename R, typename... Args> 
struct function_traits<R(T::*)(Args...) const> { 
    using return_type = R; 
    using param_types = std::tuple<Args...>; 
}; 

template<typename T> struct function_traits : public 
function_traits<decltype(&T::operator())> {}; 

template <typename T> 
T* get_arg(int id) 
{ 
    // Actual implementation omitted. Uses the id parameter to 
    // do a lookup into a table and return an existing instance 
    // of type T. 
    return new T(); 
} 

template <typename Func> 
void call_func(Func&& func, int id) 
{ 
    using param_types = function_traits<Func>::param_types>; 

    func(*get_arg<param_types>(id)...); // <--- Problem is this line 
} 

call_func([](int& a, char& b) { }, 3); 

Das Problem ist, dass func(*get_arg<param_types>(id)...); eigentlich nicht, da param_types zu kompilieren ist ein Tupel und kein Parameter Pack. Der Compiler generiert diesen Fehler: "Es sind keine Parameterpakete zum Erweitern verfügbar". Was würde ich gern geschehen sein ist für diese Linie zu erweitern:

func(*get_arg<int>(id), *get_arg<char>(id)); 

Und dass die Arbeit für eine beliebige Anzahl von Argumenten zu haben. Gibt es eine Möglichkeit, dieses Ergebnis zu erhalten?

Diese Frage scheint ähnlich, löst aber nicht mein Problem selbst: "unpacking" a tuple to call a matching function pointer. Ich habe eine Typenliste und möchte daraus eine Liste von Werten generieren, die als Funktionsargumente verwendet werden. Wenn ich die Liste der Werte hätte, könnte ich sie erweitern und die Funktion wie in dieser Frage beschrieben aufrufen, aber ich tue es nicht.

Answer 1

Nicht sicher, dass was Sie wollen.

Ich weiß nicht, wie zu erweitern, innerhalb call_func(), die Parameter Packung von params_type aber, wenn Sie die Verwendung eines Helfer-Struktur und einen Compiler mit C++ 14 ...

ich leisten haben bereitete das folgende Beispiel mit Unterstützung für Rückgabetyp vor.

#include <tuple> 

template<typename F> 
struct function_traits; 

template<typename T, typename R, typename... Args> 
struct function_traits<R(T::*)(Args...) const> { 
    using return_type = R; 
    using param_types = std::tuple<Args...>; 
}; 

template<typename T> struct function_traits : public 
function_traits<decltype(&T::operator())> {}; 

template <typename T, typename ... Args> 
T get_arg (std::tuple<Args...> const & tpl) 
{ return std::get<typename std::decay<T>::type>(tpl); } 

template <typename ...> 
struct call_func_helper; 

template <typename Func, typename Ret, typename ... Args> 
struct call_func_helper<Func, Ret, std::tuple<Args...>> 
{ 
    template <typename T, typename R = Ret> 
     static typename std::enable_if<false == std::is_same<void, R>::value, R>::type 
       fn (Func const & func, T const & t) 
     { return func(get_arg<Args>(t)...); } 

    template <typename T, typename R = Ret> 
     static typename std::enable_if<true == std::is_same<void, R>::value, R>::type 
       fn (Func const & func, T const & t) 
     { func(get_arg<Args>(t)...); } 
}; 

template <typename Func, 
      typename T, 
      typename R = typename function_traits<Func>::return_type> 
R call_func (Func const & func, T const & id) 
{ 
    using param_types = typename function_traits<Func>::param_types; 

    return call_func_helper<Func, R, param_types>::fn(func, id); 
} 

int main() 
{ 
    call_func([](int const & a, char const & b) { }, std::make_tuple(3, '6')); 

    return 0; 
} 

Hoffe das hilft.