Ein Tupel „entpacken“, um einen passenden Funktionszeiger aufzurufen

Ich versuche, in einer std::tuplevariierenden Anzahl von Werten zu speichern , die später als Argumente für einen Aufruf eines Funktionszeigers verwendet werden, der den gespeicherten Typen entspricht.

Ich habe ein vereinfachtes Beispiel erstellt, das das Problem zeigt, das ich nur schwer lösen kann:

#include <iostream>
#include <tuple>

void f(int a, double b, void* c) {
  std::cout << a << ":" << b << ":" << c << std::endl;
}

template <typename ...Args>
struct save_it_for_later {
  std::tuple<Args...> params;
  void (*func)(Args...);

  void delayed_dispatch() {
     // How can I "unpack" params to call func?
     func(std::get<0>(params), std::get<1>(params), std::get<2>(params));
     // But I *really* don't want to write 20 versions of dispatch so I'd rather 
     // write something like:
     func(params...); // Not legal
  }
};

int main() {
  int a=666;
  double b = -1.234;
  void *c = NULL;

  save_it_for_later<int,double,void*> saved = {
                                 std::tuple<int,double,void*>(a,b,c), f};
  saved.delayed_dispatch();
}

Normalerweise std::tuplewürde ich bei Problemen mit oder mit variablen Vorlagen eine andere Vorlage schreiben template <typename Head, typename ...Tail>, um alle Typen nacheinander rekursiv auszuwerten, aber ich sehe keine Möglichkeit, dies für den Versand eines Funktionsaufrufs zu tun.

Die eigentliche Motivation dafür ist etwas komplexer und meistens nur eine Lernübung. Sie können davon ausgehen, dass ich das Tupel vertraglich von einer anderen Schnittstelle erhalten habe, es kann also nicht geändert werden, aber der Wunsch, es in einen Funktionsaufruf zu entpacken, liegt bei mir. Dies std::bindschließt aus, dass das zugrunde liegende Problem auf billige Weise umgangen wird.

Was ist eine saubere Methode, um den Anruf mit dem zu versenden std::tuple, oder eine alternative bessere Methode, um das gleiche Nettoergebnis zu erzielen, indem einige Werte und ein Funktionszeiger bis zu einem beliebigen zukünftigen Punkt gespeichert / weitergeleitet werden?

Sie müssen ein Parameterpaket mit Zahlen erstellen und diese entpacken

template<int ...>
struct seq { };

template<int N, int ...S>
struct gens : gens<N-1, N-1, S...> { };

template<int ...S>
struct gens<0, S...> {
  typedef seq<S...> type;
};


// ...
  void delayed_dispatch() {
     callFunc(typename gens<sizeof...(Args)>::type());
  }

  template<int ...S>
  void callFunc(seq<S...>) {
     func(std::get<S>(params) ...);
  }
// ...

Die C ++ 17-Lösung ist einfach zu verwenden std::apply:

auto f = [](int a, double b, std::string c) { std::cout<<a<<" "<<b<<" "<<c<< std::endl; };
auto params = std::make_tuple(1,2.0,"Hello");
std::apply(f, params);

Ich hatte nur das Gefühl, dass dies einmal in einer Antwort in diesem Thread angegeben werden sollte (nachdem es bereits in einem der Kommentare erschienen ist).

Die grundlegende C ++ 14-Lösung fehlt in diesem Thread noch. EDIT: Nein, es ist tatsächlich in der Antwort von Walter.

Diese Funktion ist gegeben:

void f(int a, double b, void* c)
{
      std::cout << a << ":" << b << ":" << c << std::endl;
}

Nennen Sie es mit folgendem Snippet:

template<typename Function, typename Tuple, size_t ... I>
auto call(Function f, Tuple t, std::index_sequence<I ...>)
{
     return f(std::get<I>(t) ...);
}

template<typename Function, typename Tuple>
auto call(Function f, Tuple t)
{
    static constexpr auto size = std::tuple_size<Tuple>::value;
    return call(f, t, std::make_index_sequence<size>{});
}

Beispiel:

int main()
{
    std::tuple<int, double, int*> t;
    //or std::array<int, 3> t;
    //or std::pair<int, double> t;
    call(f, t);    
}

DEMO

Dies ist eine vollständig kompilierbare Version von Johannes 'Lösung für Awoodlands Frage, in der Hoffnung, dass sie für jemanden nützlich sein kann. Dies wurde mit einem Snapshot von g ++ 4.7 auf Debian Squeeze getestet.

###################
johannes.cc
###################
#include <tuple>
#include <iostream>
using std::cout;
using std::endl;

template<int ...> struct seq {};

template<int N, int ...S> struct gens : gens<N-1, N-1, S...> {};

template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };

double foo(int x, float y, double z)
{
  return x + y + z;
}

template <typename ...Args>
struct save_it_for_later
{
  std::tuple<Args...> params;
  double (*func)(Args...);

  double delayed_dispatch()
  {
    return callFunc(typename gens<sizeof...(Args)>::type());
  }

  template<int ...S>
  double callFunc(seq<S...>)
  {
    return func(std::get<S>(params) ...);
  }
};

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
int main(void)
{
  gens<10> g;
  gens<10>::type s;
  std::tuple<int, float, double> t = std::make_tuple(1, 1.2, 5);
  save_it_for_later<int,float, double> saved = {t, foo};
  cout << saved.delayed_dispatch() << endl;
}
#pragma GCC diagnostic pop

Man kann die folgende SConstruct-Datei verwenden

#####################
SConstruct
#####################
#!/usr/bin/python

env = Environment(CXX="g++-4.7", CXXFLAGS="-Wall -Werror -g -O3 -std=c++11")
env.Program(target="johannes", source=["johannes.cc"])

Auf meiner Maschine gibt dies

g++-4.7 -o johannes.o -c -Wall -Werror -g -O3 -std=c++11 johannes.cc
g++-4.7 -o johannes johannes.o

Hier ist eine C ++ 14-Lösung.

template <typename ...Args>
struct save_it_for_later
{
  std::tuple<Args...> params;
  void (*func)(Args...);

  template<std::size_t ...I>
  void call_func(std::index_sequence<I...>)
  { func(std::get<I>(params)...); }
  void delayed_dispatch()
  { call_func(std::index_sequence_for<Args...>{}); }
};

Dies benötigt noch eine Hilfsfunktion ( call_func). Da dies eine gängige Redewendung ist, sollte der Standard sie std::callmöglicherweise wie bei einer möglichen Implementierung direkt unterstützen

// helper class
template<typename R, template<typename...> class Params, typename... Args, std::size_t... I>
R call_helper(std::function<R(Args...)> const&func, Params<Args...> const&params, std::index_sequence<I...>)
{ return func(std::get<I>(params)...); }

// "return func(params...)"
template<typename R, template<typename...> class Params, typename... Args>
R call(std::function<R(Args...)> const&func, Params<Args...> const&params)
{ return call_helper(func,params,std::index_sequence_for<Args...>{}); }

Dann wird unser verspäteter Versand

template <typename ...Args>
struct save_it_for_later
{
  std::tuple<Args...> params;
  std::function<void(Args...)> func;
  void delayed_dispatch()
  { std::call(func,params); }
};

Dies ist etwas kompliziert zu erreichen (obwohl es möglich ist). Ich rate Ihnen , eine Bibliothek zu verwenden , wo dies bereits umgesetzt wird, nämlich Boost.Fusion (die invoke - Funktion). Als Bonus funktioniert Boost Fusion auch mit C ++ 03-Compilern.

c ++ 14Lösung. Zunächst einige Utility Boilerplate:

template<std::size_t...Is>
auto index_over(std::index_sequence<Is...>){
  return [](auto&&f)->decltype(auto){
    return decltype(f)(f)( std::integral_constant<std::size_t, Is>{}... );
  };
}
template<std::size_t N>
auto index_upto(std::integral_constant<std::size_t, N> ={}){
  return index_over( std::make_index_sequence<N>{} );
}

Mit diesen können Sie ein Lambda mit einer Reihe von Ganzzahlen zur Kompilierungszeit aufrufen.

void delayed_dispatch() {
  auto indexer = index_upto<sizeof...(Args)>();
  indexer([&](auto...Is){
    func(std::get<Is>(params)...);
  });
}

und wir sind fertig.

index_uptound index_overSie können mit Parameterpaketen arbeiten, ohne neue externe Überladungen generieren zu müssen.

Natürlich in c ++ 17 Sie gerade

void delayed_dispatch() {
  std::apply( func, params );
}

Nun, wenn uns das gefällt, in c ++ 14 wir können schreiben:

namespace notstd {
  template<class T>
  constexpr auto tuple_size_v = std::tuple_size<T>::value;
  template<class F, class Tuple>
  decltype(auto) apply( F&& f, Tuple&& tup ) {
    auto indexer = index_upto<
      tuple_size_v<std::remove_reference_t<Tuple>>
    >();
    return indexer(
      [&](auto...Is)->decltype(auto) {
        return std::forward<F>(f)(
          std::get<Is>(std::forward<Tuple>(tup))...
        );
      }
    );
  }
}

relativ leicht und den Reiniger bekommen c ++ 17 Syntax versandbereit.

void delayed_dispatch() {
  notstd::apply( func, params );
}

ersetzen Sie einfach notstdmit , stdwenn der Compiler - Upgrades und Bob ist dein Onkel.

Wenn ich über das Problem nachdenke, basierend auf der gegebenen Antwort, habe ich einen anderen Weg gefunden, das gleiche Problem zu lösen:

template <int N, int M, typename D>
struct call_or_recurse;

template <typename ...Types>
struct dispatcher {
  template <typename F, typename ...Args>
  static void impl(F f, const std::tuple<Types...>& params, Args... args) {
     call_or_recurse<sizeof...(Args), sizeof...(Types), dispatcher<Types...> >::call(f, params, args...);
  }
};

template <int N, int M, typename D>
struct call_or_recurse {
  // recurse again
  template <typename F, typename T, typename ...Args>
  static void call(F f, const T& t, Args... args) {
     D::template impl(f, t, std::get<M-(N+1)>(t), args...);
  }
};

template <int N, typename D>
struct call_or_recurse<N,N,D> {
  // do the call
  template <typename F, typename T, typename ...Args>
  static void call(F f, const T&, Args... args) {
     f(args...);
  }
};

Was erfordert, die Implementierung von delayed_dispatch()zu ändern :

  void delayed_dispatch() {
     dispatcher<Args...>::impl(func, params);
  }

Dies funktioniert, indem das rekursiv std::tuplein ein eigenständiges Parameterpaket konvertiert wird . call_or_recursewird als Spezialisierung benötigt, um die Rekursion mit dem realen Aufruf zu beenden, der nur das fertige Parameterpaket entpackt.

Ich bin mir nicht sicher, ob dies eine "bessere" Lösung ist, aber es ist eine andere Art, darüber nachzudenken und es zu lösen.

Als weitere alternative Lösung können Sie enable_ifetwas verwenden, das wohl einfacher ist als meine vorherige Lösung:

#include <iostream>
#include <functional>
#include <tuple>

void f(int a, double b, void* c) {
  std::cout << a << ":" << b << ":" << c << std::endl;
}

template <typename ...Args>
struct save_it_for_later {
  std::tuple<Args...> params;
  void (*func)(Args...);

  template <typename ...Actual>
  typename std::enable_if<sizeof...(Actual) != sizeof...(Args)>::type
  delayed_dispatch(Actual&& ...a) {
    delayed_dispatch(std::forward<Actual>(a)..., std::get<sizeof...(Actual)>(params));
  }

  void delayed_dispatch(Args ...args) {
    func(args...);
  }
};

int main() {
  int a=666;
  double b = -1.234;
  void *c = NULL;

  save_it_for_later<int,double,void*> saved = {
                                 std::tuple<int,double,void*>(a,b,c), f};
  saved.delayed_dispatch();
}

Die erste Überladung nimmt nur ein weiteres Argument aus dem Tupel und fügt es in ein Parameterpaket ein. Die zweite Überlastung nimmt ein passendes Parameterpaket und führt dann den eigentlichen Aufruf durch, wobei die erste Überlastung in dem einzigen Fall deaktiviert wird, in dem die zweite realisierbar wäre.

Meine Variation der Lösung von Johannes unter Verwendung von C ++ 14 std :: index_sequence (und Funktionsrückgabetyp als Vorlagenparameter RetT):

template <typename RetT, typename ...Args>
struct save_it_for_later
{
    RetT (*func)(Args...);
    std::tuple<Args...> params;

    save_it_for_later(RetT (*f)(Args...), std::tuple<Args...> par) : func { f }, params { par } {}

    RetT delayed_dispatch()
    {
        return callFunc(std::index_sequence_for<Args...>{});
    }

    template<std::size_t... Is>
    RetT callFunc(std::index_sequence<Is...>)
    {
        return func(std::get<Is>(params) ...);
    }
};

double foo(int x, float y, double z)
{
  return x + y + z;
}

int testTuple(void)
{
  std::tuple<int, float, double> t = std::make_tuple(1, 1.2, 5);
  save_it_for_later<double, int, float, double> saved (&foo, t);
  cout << saved.delayed_dispatch() << endl;
  return 0;
}