«Décompresser» un tuple pour appeler un pointeur de fonction correspondant

J'essaie de stocker dans un std::tuplenombre variable de valeurs, qui seront plus tard utilisées comme arguments pour un appel à un pointeur de fonction qui correspond aux types stockés.

J'ai créé un exemple simplifié montrant le problème que j'ai du mal à résoudre:

#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();
}

Normalement, pour les problèmes impliquant std::tupledes modèles variadiques, j'écrirais un autre modèle, comme template <typename Head, typename ...Tail>pour évaluer récursivement tous les types un par un, mais je ne vois pas de moyen de le faire pour envoyer un appel de fonction.

La vraie motivation pour cela est un peu plus complexe et c'est surtout juste un exercice d'apprentissage de toute façon. Vous pouvez supposer que le tuple m'a été remis par contrat à partir d'une autre interface, donc ne peut pas être changé, mais que le désir de le décompresser dans un appel de fonction est le mien. Cela exclut l'utilisation std::bindcomme moyen bon marché de contourner le problème sous-jacent.

Quelle est une façon propre de répartir l'appel à l'aide de la std::tuple, ou une meilleure façon alternative d'obtenir le même résultat net de stockage / transfert de certaines valeurs et d'un pointeur de fonction jusqu'à un point futur arbitraire?

La solution C ++ 17 consiste simplement à utiliser 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);

Je pense que cela devrait être indiqué une fois dans une réponse dans ce fil (après qu'il soit déjà apparu dans l'un des commentaires).

La solution de base C ++ 14 est toujours manquante dans ce thread. EDIT: Non, c'est en fait là dans la réponse de Walter.

Cette fonction est donnée:

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

Appelez-le avec l'extrait de code suivant:

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>{});
}

Exemple:

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

DEMO

Vous devez créer un ensemble de paramètres de nombres et les décompresser

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) ...);
  }
// ...

Il s'agit d'une version compilable complète de la solution de Johannes à la question d'Awoodland, dans l'espoir qu'elle puisse être utile à quelqu'un. Cela a été testé avec un instantané de g ++ 4.7 sur Debian Squeeze.

###################
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

On peut utiliser le fichier SConstruct suivant

#####################
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"])

Sur ma machine, cela donne

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

Voici une solution C ++ 14.

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...>{}); }
};

Cela nécessite toujours une fonction d'assistance ( call_func). Puisqu'il s'agit d'un idiome commun, la norme devrait peut-être le prendre en charge directement comme std::callpour une implémentation possible

// 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...>{}); }

Ensuite, notre envoi retardé devient

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

C'est un peu compliqué à réaliser (même si c'est possible). Je vous conseille d'utiliser une bibliothèque où cela est déjà implémenté, à savoir Boost.Fusion (la fonction invoke ). En prime, Boost Fusion fonctionne également avec les compilateurs C ++ 03.

c ++ 14Solution. Tout d'abord, certains passe-partout utilitaires:

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>{} );
}

Ceux-ci vous permettent d'appeler un lambda avec une série d'entiers au moment de la compilation.

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

et nous avons terminé.

index_uptoet index_overvous permet de travailler avec des packs de paramètres sans avoir à générer de nouvelles surcharges externes.

Bien sûr, dans c ++ 17 tu viens

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

Maintenant, si on aime ça, c ++ 14 nous pouvons écrire:

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))...
        );
      }
    );
  }
}

relativement facilement et obtenir le nettoyeur c ++ 17 syntaxe prête à être expédiée.

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

il suffit de le remplacer notstdpar stdlorsque votre compilateur est mis à niveau et que bob est votre oncle.

En réfléchissant un peu plus au problème en fonction de la réponse donnée, j'ai trouvé une autre façon de résoudre le même problème:

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...);
  }
};

Ce qui nécessite de changer la mise en œuvre de delayed_dispatch():

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

Cela fonctionne en convertissant récursivement le std::tupleen un pack de paramètres à part entière. call_or_recurseest nécessaire comme spécialisation pour terminer la récursivité avec l'appel réel, qui décompresse simplement le pack de paramètres terminé.

Je ne suis pas sûr que ce soit de toute façon une "meilleure" solution, mais c'est une autre façon de penser et de la résoudre.

Comme autre solution alternative que vous pouvez utiliser enable_if, pour former quelque chose sans doute plus simple que ma solution précédente:

#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();
}

La première surcharge prend simplement un argument de plus du tuple et le place dans un pack de paramètres. La deuxième surcharge prend un pack de paramètres correspondant, puis effectue l'appel réel, la première surcharge étant désactivée dans le seul et unique cas où le second serait viable.

Ma variation de la solution de Johannes utilisant le std :: index_sequence C ++ 14 (et le type de retour de fonction comme paramètre de modèle 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;
}