Построение списка времени компиляции постепенно в переполнении стека

Вы можете использовать вариационные шаблоны C ++ 11 напрямую, они позволяют писать списки типов гораздо более изящным способом, чем классический функционал. head:tail подход:

template<typename... Ts>
struct list{};

using l = list<int,char,bool>;

С другой стороны, если вам нравится способ «голова-хвост», вы можете переводить из одного формата в другой. В этом случае (Variadic к функционалу):

template<typename HEAD , typename TAIL>
struct list{};

struct nil{};

template<typename... Ts>
struct make_list;

template<typename HEAD , typename... TAIL>
struct make_list<HEAD,TAIL>
{
using result = list<HEAD,typename make_list<TAIL...>::result;
};

template<>
struct make_list<>
{
using result = nil;
};

Пример:

//l is list<int,list<char,list<bool,nil>>>
using l = typename make_list<int,char,bool>::result;

Конечно, вы можете использовать псевдонимы шаблонов, чтобы сделать синтаксис более понятным:

template<typename... Ts>
using make = typename make_list<Ts...>::result;

using l = make<int,char,bool>;

Я нашел решение! Хотя это немного более ограничено; Вы должны предоставить уникальное имя для каждого элемента, и должен быть верхний предел количества элементов (здесь 100).

#include <type_traits>

// Good old Cons and Nil.
template <typename THead, typename TTail>
struct Cons {
using Head = THead;
using Tail = TTail;
};
struct Nil {};

// Helper template which builds a list from a template
// providing elements at given indices.
template <template<int> class ElemAt, int Offset, int Length>
struct BuildListFromElemAt {
using Result = Cons<typename ElemAt<Offset>::Elem, typename BuildListFromElemAt<ElemAt, (Offset + 1), (Length - 1)>::Result>;
};
template <template<int> class ElemAt, int Offset>
struct BuildListFromElemAt<ElemAt, Offset, 0> {
using Result = Nil;
};

// This is where the abuse begins.
// We use these classes to keep the current length
// of the list, in combination with function overloads.
// Each time we add an element, we will provide a more
// specific overload of a helper function.
template <int N>
struct Counter : public Counter<(N - 1)> {
static int const Num = N;
};
template <>
struct Counter<0> {
static int const Num = 0;
};

// At the beginning, we define the initial size function
// taking Counter<0>, and declare the ElemAt template.
#define BEGIN_LIST(ListName) \
Counter<0> ListName##_Size (Counter<0>); \
template <int Index> struct ListName##_ElemAt;

// For each element, we retrieve the current length of the
// list by checking the return type of calling the size function
// with a very large Counter.
// Then we overload the size function for one greater Counter,
// which ensures that we get an incremented length at the next
// step. We also define the ElemAt for this index to return the
// given Value.
#define ADD_TO_LIST(ListName, Name, Value) \
static int const ListName##_##Name##_PrevLen = decltype(ListName##_Size(Counter<100>()))::Num; \
static int const ListName##_##Name##_Len = ListName##_##Name##_PrevLen + 1; \
Counter<ListName##_##Name##_Len> ListName##_Size (Counter<ListName##_##Name##_Len>); \
template <> struct ListName##_ElemAt<ListName##_##Name##_PrevLen> { \
using Elem = Value; \
};

// At the end, we retrieve the final length of the list,
// and build the list using the BuildListFromElemAt template.
#define END_LIST(ListName) \
static int const ListName##_Len = decltype(ListName##_Size(Counter<100>()))::Num; \
using ListName = typename BuildListFromElemAt<ListName##_ElemAt, 0, ListName##_Len>::Result;

// Here we go...
BEGIN_LIST(List)
ADD_TO_LIST(List, First, int)
ADD_TO_LIST(List, Second, float)
ADD_TO_LIST(List, Third, double)
END_LIST(List)

// And it works :)
static_assert(std::is_same<typename List::Head, int>::value, "");
static_assert(std::is_same<typename List::Tail::Head, float>::value, "");
static_assert(std::is_same<typename List::Tail::Tail::Head, double>::value, "");