Création de paires d'index et de type à partir d'un paquet de paramètres

Question

J'essaie de créer un tuple ou des paires de l'index d'un pack de paramètres.

Voici un exemple de ce que le code veut réaliser :

  {
    using Indices =
        std::tuple< IndexTypePair< 0, int >, IndexTypePair< 1, int >, IndexTypePair< 2, float > >;
    test2< Indices, 0 >();
    test2< Indices, 1 >();
    test2< Indices, 2 >();
  }

Et voilà la généralisation :

  {
    template < typename... T >
    using make_index_tuple = tuple< IndexTypePair< Index_v< T, T... >, T >... >;
    using Indices = make_index_tuple< int, int, float >;
    test2< Indices, 0 >();
    test2< Indices, 1 >();
    test2< Indices, 2 >();
  }

Cette solution est basée sur la réponse à cette question : Comment obtenir l'index d'un type dans un paquet de type variadique ?

Un des problèmes que j'ai est de créer l'alias du modèle variadique, le code précédent donne l'erreur suivante :

$ make index-sequence clang++-3.8 -Wall -Werror -Wextra -std=c++14
-pedantic -Wconversion -stdlib=libc++ -O3 -pthread    index-sequence.cpp   -o index-sequence index-sequence.cpp:50:5: error: expected expression
    template < typename... T >
    ^ index-sequence.cpp:52:21: error: unknown type name 'make_index_tuple'
    using Indices = make_index_tuple< int, int, float >;
                    ^ ...

---

Voici quelques autres éléments qui permettent de faire fonctionner ce code :

#include <array>
#include <cstddef>
#include <iostream>
#include <type_traits>
#include <utility>

template < typename T, typename... Ts >
struct Index;

template < typename T, typename... Ts >
struct Index< T, T, Ts... > : std::integral_constant< std::size_t, 0 >
{
};

template < typename T, typename U, typename... Ts >
struct Index< T, U, Ts... > : std::integral_constant< std::size_t, 1 + Index< T, Ts... >::value >
{
};

template < typename T, typename... Ts >
constexpr std::size_t Index_v = Index< T, Ts... >::value;

template < size_t i, typename T >
struct IndexTypePair
{
  static constexpr size_t index{i};
  using Type = T;
};

template < typename Idx, size_t i >
void test2()
{
  using ITP = typename std::tuple_element< i, Idx >::type;
  typename ITP::Type v{};
  //....
  std::cout << ITP::index << ' ' << v << std::endl;
}

Answer 1

Utilisez une configuration de structure imbriquée pour vous aider, ainsi que la fonction standard make_index_sequence :

template < typename ... T >
struct make_index_type_tuple_helper
{    
    template< typename V >
    struct idx;

    template< size_t ... Indices >
    struct idx<std::index_sequence<Indices...>>
    {
        using tuple_type = std::tuple<IndexTypePair<Indices, T>...>;
    };

    using tuple_type = typename idx<std::make_index_sequence<sizeof...(T)>>::tuple_type;
};

template < typename ... T>
using make_index_type_tuple = typename make_index_type_tuple_helper<T...>::tuple_type;

Ensuite, vous pouvez l'utiliser exactement comme vous le souhaitez ( Démonstration en direct ) :

using Indices = make_index_type_tuple< int, int, float >;
test2< Indices, 0 >();
test2< Indices, 1 >();
test2< Indices, 2 >();