Введение
Мой ответ пытается быть предпочтительным для пользователей C ++ 11.
Ответ Джоэля Фалькоу хорош для старого стандарта, но C ++ 11
Пакеты параметров часто делают последовательности типа надстройки устаревшими. Более того, я думаю, что в этом случае лучше использовать шаблоны с копилкой, чем boost::lambda.
На самом деле мое решение вообще не использует никаких включений, кроме декартового шаблона продукта, который я возьму из здесь , поскольку его нет в стандартной библиотеке.
Использование новейших функций (начиная с C ++ 11) позволяет кодировать решение, которое:
- Весы лучше.
- короче
- Более читабелен, поскольку решение разделяет проблемы.
Объяснение различных шаблонов:
expand_pack выполняет свои параметры. Это позволяет повторять исполняемый код с использованием многоточия. Пример: expand_pack(new T{}...). Кто-нибудь знает название этой идиомы ?
wrap_template_as_type Копировать шаблон, чтобы его можно было использовать там, где ожидается тип. Возможно, эта идиома называется повторное связывание шаблона или позднее связывание шаблона .
Я не знаю, поэтому я разместил этот вопрос здесь. Примеры: wrap_template_as_type<map> и наоборот wrapper::unwrapp<int, string>
type_list кортеж без данных, колокольчики и писсуары.
template_list шаблон, который принимает список шаблонов и возвращает список type_list с оригинальными шаблонами, помещенными в оболочку.
make_host_type преобразует A, B, C, D в A<B<C<D>>>
all_hosts получает набор типов хостов и новости по одному хосту для каждого элемента входного кортежа.
Полный пример
Обратите внимание, что #include http://... необходимо заменить на связанный контент
Обратите внимание, что MSVC не понимает PRETTY_FUNCTION , но FUNCDNAME Я думаю
#include <iostream>
#include <typeinfo>
#include https://stackoverflow.com/a/19611856/2712726
template<typename... Ts> void expand_pack (Ts... t) {}
template <template<typename...> class T>
struct wrapp_template_as_type {
template <typename... Us> using unwrapp = T <Us...>;
};
template<typename... T> struct type_list {};
template <template<typename...> class... Ts>
struct template_list {
using type = type_list< wrapp_template_as_type<Ts>... >;
};
struct TraitA{}; struct TraitB{}; struct TraitC{}; struct TraitD{}; struct TraitE{}; struct TraitF{};
template<typename Trait> struct WhateverA{};
template<typename Trait> struct WhateverB{};
template<typename Whatever> struct FunctionalityA{};
template<typename Whatever> struct FunctionalityB{};
template<typename Whatever> struct FunctionalityC{};
template<typename Whatever> struct FunctionalityD{};
template<typename Func> struct FuncUserA{};
template<typename Func> struct FuncUserB{};
template<typename Func> struct FuncUserC{};
template<typename FuncUser> struct Host { Host() {std::cout << __PRETTY_FUNCTION__ << std::endl;}};
template<typename T> struct make_host_type;
template<template<typename...> class List, typename T, typename... Ts>
struct make_host_type < List<T, Ts...> > {
using type = typename T::template unwrapp < typename make_host_type< List<Ts...> >::type >;
};
template<template<typename...> class List, typename T>
struct make_host_type < List<T> > {
using type = T;
};
template <typename T> struct all_hosts;
template <template<typename...> class Hosts, typename... Ts>
struct all_hosts <Hosts<Ts...> > {
static void create () {
expand_pack (new typename make_host_type<Ts>::type{}...);
}
};
int main () {
using a = type_list < TraitA, TraitB, TraitC, TraitD, TraitE, TraitF >;
using b = typename template_list < WhateverA, WhateverB>::type;
using c = typename template_list < FunctionalityA, FunctionalityB, FunctionalityC, FunctionalityD >::type;
using d = typename template_list < FuncUserA, FuncUserB, FuncUserC >::type;
using e = typename template_list < Host >::type;
using p = typename product<type_list, e, d, c, b, a>::type; // create a type_list of all possible Host types.
all_hosts<p>::create(); // calls constructor for each Host type
}
Вывод: (Если вы используете MSVC, замените PRETTY_FUNCTION на что-то другое)
Host<FuncUser>::Host() [with FuncUser = FuncUserC<FunctionalityD<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserB<FunctionalityD<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserA<FunctionalityD<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserC<FunctionalityC<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserB<FunctionalityC<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserA<FunctionalityC<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserC<FunctionalityB<WhateverB<TraitF> > >]
Host<FuncUser>::Host() [with FuncUser = FuncUserB<FunctionalityB<WhateverB<TraitF> > >]
...
Host<FuncUser>::Host() [with FuncUser = FuncUserA<FunctionalityA<WhateverA<TraitA> > >]