Parameter pack expansion for static variables

A lazy solution using std::tuple:

• make a tuple of DATA and SIZE for each element of the parameter pack,
• flatten the list of tuples to one big tuple using std::tuple_cat,
• apply the resulting tuple's elements to Concatenation by expanding a list of indexes in an std::index_sequence.

In the following code, the test harness is longer than the actual solution:

#include <cstddef>
#include <tuple>
#include <utility>
#include <iostream>
#include <typeinfo>
#include <type_traits>

struct MyArray { };
template<class... ARGS> MyArray Concatenation(ARGS... args) 
{
   // Just some dummy code for testing.
   using arr = int[];
   (void)arr{(std::cout << typeid(args).name() << ' ' << args << '\n' , 0)...};
   return {}; 
}

struct A { static void* DATA; static std::size_t SIZE; };
struct B { static void* DATA; static std::size_t SIZE; };
struct C { static void* DATA; static std::size_t SIZE; };

// Also needed for testing.
void* A::DATA;
std::size_t A::SIZE;
void* B::DATA;
std::size_t B::SIZE;
void* C::DATA;
std::size_t C::SIZE;


// The useful stuff starts here.

template<class T, std::size_t... Is> MyArray concat_hlp_2(const T& tup, std::index_sequence<Is...>)
{
   return Concatenation(std::get<Is>(tup)...);
}

template<class T> MyArray concat_hlp_1(const T& tup)
{
   return concat_hlp_2(tup, std::make_index_sequence<std::tuple_size<T>::value>{});
}

template<class... ARGS> MyArray AutoConcatenation()
{
   return concat_hlp_1(std::tuple_cat(std::make_tuple(ARGS::DATA, ARGS::SIZE)...));
}


int main()
{
   AutoConcatenation<A, B, C>();
}

If you want to avoid std::tuple and std::tuple_cat (which can be heavy in terms of compile times), here's an alternative using indexes into arrays.

The testing code stays the same, this is just the juicy stuff:

template<std::size_t Size> const void* select(std::false_type, std::size_t idx,
   const void* (& arr_data)[Size], std::size_t (&)[Size])
{
   return arr_data[idx];
}

template<std::size_t Size> std::size_t select(std::true_type, std::size_t idx,
   const void* (&)[Size], std::size_t (& arr_size)[Size])
{
   return arr_size[idx];
}

template<std::size_t... Is> MyArray concat_hlp(std::index_sequence<Is...>, 
   const void* (&& arr_data)[sizeof...(Is) / 2], std::size_t (&& arr_size)[sizeof...(Is) / 2])
{
   return Concatenation(select(std::bool_constant<Is % 2>{}, Is / 2, arr_data, arr_size)...);
}

template<class... ARGS> MyArray AutoConcatenation()
{
   return concat_hlp(std::make_index_sequence<sizeof...(ARGS) * 2>{}, {ARGS::DATA...}, {ARGS::SIZE...});
}

Again a sequence of indexes twice the size of the original parameter pack, but we build separate arrays of DATA and SIZE and then use tag dispatching to select elements from one or the other depending on the parity of the current index.

This may not look as nice as the previous code, but it doesn't involve any template recursion (std::make_index_sequence is implemented using compiler intrinsics in modern compilers as far as I know) and cuts down on the number of template instantiations, so it should be faster to compile.

The select helper can be made constexpr by using arrays of pointers to the static members, but this turns out to be unnecessary in practice. I've tested MSVC 2015 U2, Clang 3.8.0 and GCC 6.1.0 and they all optimize this to a direct call to Concatenation (just like for the tuple-based solution).