Comment obtenir le i-ème élément à partir d'un std::tuple quand je ne sais pas au moment de la compilation?

C'est possible:

struct Functor 
{
    template<typename T>
    void operator()(T& t) const { std::cout << t << std::endl; }
};

template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
  for_index(int, std::tuple<Tp...> &, FuncT)
  { }

template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), void>::type
  for_index(int index, std::tuple<Tp...>& t, FuncT f)
  {
    if (index == 0) f(std::get<I>(t));
    for_index<I + 1, FuncT, Tp...>(index-1, t, f);
  }

auto t = make_tuple(1, 2, "abc", "def", 4.0f);
int i = 2; //for example
for_index(i, t, Functor());

Ce code affichera:

abc

Échantillon de travail sur ideone: l'échantillon

OriginalL'auteur Victor Laskin

La question ici, quel serait le type de type de retour si ce serait possible? Il doit être connu au moment de la compilation, mais tuple peut contenir des éléments de types différents.

Imaginons que nous avons un tuple de trois éléments:

auto tuple = std::make_tuple(10, "", A());
using tuple_type = decltype(tuple);

Apparemment, l'obtention de la N-ième élément n'a pas beaucoup de sens. Ce type serait-il? On ne sait pas jusqu'à l'exécution. Cependant, plutôt que d'arriver à la N-ième élément, vous pouvez appliquer une fonction à elle, étant donné que tous les éléments à l'appui de certaines protocole commun:

void process(int n)
{
  if (n == 0)
    func(std::get<0>(tuple));
  else if (n == 1)
    func(std::get<1>(tuple));
  else if (n == 2)
    func(std::get<2>(tuple));
}

Ce code "dynamique" des processus de l'élément, compte tenu de l'indice de n. Le protocole commun dans cet exemple est la fonction func qui peut faire quelque chose de significatif avec tous les types possibles utilisé dans le tuple.

Cependant, la rédaction d'un tel code à la main est fastidieux, nous voulons le rendre plus générique. Commençons par l'extraction de la fonction de l'application, de sorte que nous pouvons réutiliser les mêmes process fonction pour différentes foncteurs:

template<template<typename > class F>
void process(int n)
{
  if (n == 0)
  {
    using E = typename std::tuple_element<0, tuple_type>::type;
    F<E>::apply(std::get<0>(tuple));
  }
  else if (n == 1)
  {
    using E = typename std::tuple_element<1, tuple_type>::type;
    F<E>::apply(std::get<1>(tuple));
  }
  else if (n == 2)
  {
    using E = typename std::tuple_element<2, tuple_type>::type;
    F<E>::apply(std::get<2>(tuple));
  }
}

Dans ce cas F pourraient être mises en œuvre en tant que quelque chose comme:

//Prints any printable type to the stdout
struct printer
{
  static void apply(E e)
  {
    std::cout << e << std::endl;
  }
}

Faisons compilateur de générer tout le code, nous allons le rendre générique:

constexpr static std::size_t arity = std::tuple_size<tuple_type>::value;
template<int N>
struct wrapper
{
  template<template<typename, typename ... > class F>
  static void apply_to(tuple_type& tuple, int idx)
  {
    if (idx)
      //Double recursion: compile and runtime.
      //Compile-time "recursion" will be terminated once
      //we reach condition N == tuple arity
      //Runtime recursion terminates once idx is zero.
      wrapper<N + 1>::template apply_to<F>(tuple, idx - 1);
    else
    {
      //idx == 0 (which means original index is equal to N).
      using E = typename std::tuple_element<N, tuple_type>::type;
      F<E>::apply(std::get<N>(tuple));
    }
  }
};

//Termination condition: N == arity.
template<>
struct wrapper<arity>
{
  template<template<typename, typename ... > class F>
  static void apply_to(tuple_type&, int)
  {
    //Throw exception or something. Index is too big.
  }
};

Utilisation:

wrapper<0>::template apply_to<printer>(tuple, 2);

Ce qui le rend complètement générique est une autre histoire, cependant. Au moins, il doit être indépendant de la tuple de type. Alors, vous voulez probablement generify type de retour de la functor, de sorte que vous pouvez revenir résultat significatif. Troisièmement, de faire foncteur d'accepter des paramètres supplémentaires.

P. S. je ne suis pas réel développeur C++, de sorte que l'approche ci-dessus peut être totale nonsence. Cependant, j'ai trouvé utile pour mon microcontrôleur projet où je veux, autant que possible, être réglé au moment de la compilation et pourtant suffisamment générique, donc je peux shuffle choses facilement. Par exemple, un "menu" dans mon projet est fondamentalement un tuple de "mesures", il y a chaque action est une catégorie distincte qui prend en charge protocole simple comme "imprimer votre étiquette à la position actuelle sur l'écran LCD" et "activer et exécuter votre INTERFACE utilisateur boucle".

OriginalL'auteur Ivan Dubrov