Использование препроцессора boost для итеративного вызова шаблона с переменным числом аргументов

Я не знаю, лучший ли это подход к решению вашей проблемы, но это делает то, что вы хотите:

#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/preprocessor/seq.hpp>
#include <boost/preprocessor/variadic/to_seq.hpp>

#define CALL_MACRO(_,__,SEQ) Macro(Foo<BOOST_PP_SEQ_ENUM(SEQ)>)

#define GENERATE_MACRO_INVOCATIONS(SEQS) BOOST_PP_SEQ_FOR_EACH(CALL_MACRO,_,SEQS)

#define GENERATE_DESCENDING_SEQUENCES(_,INDEX,DATA) (BOOST_PP_SEQ_REST_N(INDEX,DATA))

#define BAR_IMPL(SEQ) GENERATE_MACRO_INVOCATIONS(BOOST_PP_REPEAT_FROM_TO(0,BOOST_PP_SEQ_SIZE(SEQ),GENERATE_DESCENDING_SEQUENCES, SEQ))


#define Bar(...) BAR_IMPL(BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))

Bar(float, int, string, vector<int>)

• У вас изначально есть переменные данные: float, int, string, vector<int>.
• BOOST_PP_VARIADIC_TO_SEQ преобразует его в: (float)(int)(string)(vector<int>)
• BOOST_PP_REPEAT_FROM_TO вызывает макрос GENERATE_DESCENDING_SEQUENCES BOOST_PP_SEQ_SIZE(SEQ) раз с последовательностью в качестве данных и индексом, начинающимся с 0.
• BOOST_PP_SEQ_REST_N(INDEX,DATA) удаляет INDEX первых элементов из DATA и возвращает остальные. Этот результат заключен в пару круглых скобок.

• После вызова REPEAT у вас есть последовательность последовательностей:

  ((float)(int)(string)(vector))((int)(string)(vector))((string) (вектор))((вектор))

• BOOST_PP_SEQ_FOR_EACH вызывает CALL_MACRO с каждым элементом в последовательности последовательностей.

• И, наконец, BOOST_PP_SEQ_ENUM берет последовательность и возвращает ее элементы, разделенные запятыми.

Предварительно обработано на Coliru

Обновление: отредактированный ответ на основе комментариев. Теперь вызывает макрос BOOST_EXPORT_CLASS вместо функции macro(), которую я определил. Я не проверял это с BOOST_EXPORT_CLASS, однако я провел симуляцию, обращаясь к типу Foo<...> на каждом уровне расширения шаблона. Я смог получить доступ к каждому из разных типов для разных расширений, поэтому я предполагаю, что все, что делает BOOST_EXPORT_CLASS, должно работать.

Я думаю, что теперь это делает то, что вы хотите:

#define BAR(...) Foo<__VA_ARGS__>()

// Variadic definition of Foo
template <typename... Args>
struct Foo;

// Specialize Foo for the case that there is at least on template parameter
template <typename Arg, typename... Args>
struct Foo<Arg, Args...> : Foo<Args...> {
  using type = Foo<Arg, Args...>;
  Foo() : Foo<Args...>(){
    BOOST_EXPORT_CLASS(type)
  }
};

// Terminating case for Foo
template <>
struct Foo<> {
  using type = Foo<>;
  Foo() { BOOST_EXPORT_CLASS(type) }
};

int main() {
  BAR(int, float, double);
}

Чтобы проверить, что это теоретически должно работать, я определил следующий макрос:

#define MACRO(x) test<x>();

И заменил BOOST_EXPORT_CLASS(type) на MACRO(type). Функция test следующая:

template <typename T>
void test() {
  std::cout << typeid(T).name() << "\n";
}

Запуск кода напечатал следующее (я добавил комментарии), которое показывает, что шаблоны расширены в макросе и должны отображаться как BOOST_EXPORT_CLASS, как показано в вопросе:

3FooIJEE      // Foo<>
3FooIJdEE     // Foo<double>
3FooIJfdEE    // Foo<float, double>
3FooIJifdEE   // Foo<int, float, double>

Вот живая демонстрация кода Живая демонстрация.

Следует отметить, что расширение идет в направлении, противоположном указанному в OP, то есть:

Macro(Foo<>)
Macro(Foo<double>)
Macro(Foo<float, double>)
Macro(Foo<int, float, double>)