Перекомпоновка данных во время компиляции?

Я считаю, что у меня есть относительно простое решение для вариационных шаблонов.

Однако для реализации потребуется пара помощников, поэтому я представлю их задом наперед, чтобы вы могли вначале понять суть.

template <typename... Args>
class OptimizedLayout {
public:
template <size_t I>
auto at() -> decltype(std::get<Index<I>::value>(_storage)) {
return std::get<Index<I>::value>(_storage);
}

template <size_t I>
auto at() const -> decltype(std::get<Index<I>::value>(_storage)) {
return std::get<Index<I>::value>(_storage);
}

private:
using Indexed = /**/; // pairs of sorted Args (by decreasing size)
// and their original index in the argument list

using Storage = /*std::tuple<Indexed.first ...>*/;

template <size_t I>
using Index = /*index of element of Indexed whose .second is I*/;

Storage _storage;
}; // class OptimizedLayout

Основное преимущество заключается в том, что изменение способа упаковки элементов влияет только на то, как Indexed определяется, так что вы можете легко улучшить алгоритм. Пока я просто предоставлю эквивалент вашего шаблона.

Отказ от ответственности: следующий код не проверен, он может даже не скомпилироваться, не говоря уже о правильном результате.

I. Генерация индексов.

Объяснение можно найти на салон, мы можем использовать его для генерации пачки пар (тип, индекс). Для сортировки мы будем использовать алгоритм MPL, поэтому проще создать пакет в виде Вектор MPL.

template <std::size_t... Is>
struct indices {};

template <std::size_t N, std::size_t... Is>
struct build_indices
: build_indices<N-1, N-1, Is...> {};

template <std::size_t... Is>
struct build_indices<0, Is...> { using type = indices<Is...>; };

template <typename Tuple, typename Indices>
struct IndexedImpl;

template <typename... T, size_t... I>
struct IndexedImpl< std::tuple<T...>, indices<I...> > {
using type = boost::mpl::vector< std::pair<T, I>... >;
};

template <typename Tuple>
using Indexed =
IndexedImpl<Tuple, typename build_indices<std::tuple_size<Tuple>::value>::type>;

II. Сортировка

Для сортировки мы будем использовать Алгоритм сортировки MPL, который работает на типах.

struct GreaterSize {
template <typename T, typename U>
struct apply {
using type = boost::mpl::bool_<sizeof(T) > sizeof(U)>;
};
};

template <typename T>
struct TupleInserter {
using state = T;

template <typename Seq, typename E>
struct apply;
};

template <typename T>
template <typename... Args, typename E>
struct TupleInserter<T>::apply<std::tuple<Args...>, E> {
using type = std::tuple<Args..., E>;
};

template <typename Tuple>
using SortedSequence = boost::mpl::sort<
typename Indexed<Tuple>::type,
GreaterSize,
TupleInserter
>;

III. Вычисление класса хранения

Теперь нам нужно только вычислить класс хранения, который делается путем извлечения первого элемента каждой пары. Интересно, что сопоставление с образцом может действительно помочь здесь.

template <typename T>
struct TupleFirstExtractor;

template <typename... T, size_t... I>
struct TupleFirstExtractor<std::tuple<std::pair<T, I>...>> {
using type = std::tuple<T...>;
};

Внутривенно Вычисление решателя индекса

template <typename Tuple, size_t Needle, size_t Acc>
struct IndexFinderImpl;

template <typename H, size_t h, typename... Tail, size_t Needle, size_t Acc>
struct IndexFinderImpl<std::tuple<std::pair<H,h>, Tail...>, Needle, Acc>:
IndexFinderImpl<std::tuple<Tail...>, Needle, Acc+1> {};

template <typename H, typename... Tail, size_t Needle, size_t Acc>
struct IndexFinderImpl<std::tuple<std::pair<H, Needle>, Tail...>, Needle, Acc>:
std::integral_constant<size_t, Acc> {};

V. Собираем все вместе

А теперь мы подключаем все:

template <typename... Args>
class OptimizedLayout {
public:
template <size_t I>
auto at() -> decltype(std::get<Index<I>::value>(_storage)) {
return std::get<Index<I>::value>(_storage);
}

template <size_t I>
auto at() const -> decltype(std::get<Index<I>::value>(_storage)) {
return std::get<Index<I>::value>(_storage);
}

private:
using Indexed = typename SortedSequence<std::tuple<Args...>>::type;

using Storage = typename TupleFirstExtractor<Indexed>::type;

template <size_t I>
using Index = IndexFinderImpl<Indexed, I, 0>;

Storage _storage;
}; // class OptimizedLayout

Подсказка: я советую использовать специализированное пространство имен для хранения всех помощников. Хотя они могут быть определены в шаблоне, их легче определить снаружи, поскольку они не зависят от Args...однако вам необходимо изолировать их, чтобы избежать конфликтов с другими частями вашей программы.