XKpe XKpe - 4 months ago 26
C++ Question

Creating pairs of index and type from parameter pack

I'm trying to create a tuple or pairs of the index a parameter pack.

Here is an example of what the code wants to achieve:

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


And here is the generalization:

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


This solution is based on the answer to this question:
How to get the index of a type in a variadic type pack?

One of the problems I'm having is to create the variadic template alias, the previous code gives the following error:

$ 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 >;
^ ...





Here are some other bits and pieces to make this code work:

#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

Use a nested structure setup to help you, together with the 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;

Then you can use it exactly how you want (live demo):

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